chore(deps): fix npm audit vulnerabilities (axios, vite)

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

.github/workflows/release.yml

@@ -19,12 +19,7 @@ jobs:
         uses: actions/setup-node@v5
         with:
           node-version: lts/*
-      - name: cache npm
-        uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-          restore-keys: ${{ runner.os }}-npm-
+          cache: 'npm'
       - name: get version
         id: get-version
         run: echo "version=$(node -p "require('./package.json').version")" >> $GITHUB_OUTPUT
@@ -97,12 +92,7 @@ jobs:
         uses: actions/setup-node@v5
         with:
           node-version: lts/*
-      - name: cache npm
-        uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-          restore-keys: ${{ runner.os }}-npm-
+          cache: 'npm'
       - name: install Rust stable
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -141,13 +131,7 @@ jobs:
         uses: actions/setup-node@v5
         with:
           node-version: lts/*
-
-      - name: cache npm
-        uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-          restore-keys: ${{ runner.os }}-npm-
+          cache: 'npm'
 
       - name: install Rust stable
         uses: dtolnay/rust-toolchain@stable

.gitignore

@@ -40,3 +40,6 @@ memory/
 
 # Local scratchpad / notes (not committed)
 tmp/
+
+# Third-party clones for local research (not committed)
+research/

CHANGELOG.md

@@ -5,6 +5,228 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.34.8] - 2026-04-10
+
+### Added
+
+- **Netease Cloud Music Lyrics** *(opt-in)*: Netease Cloud Music can now be enabled in Settings → General as a last-resort lyrics fallback. It only fires when neither the server nor LRCLIB return results — the existing lyrics chain is completely unaffected. Particularly useful for Asian and international music. Chinese metadata lines (作词/作曲/编曲 etc.) are automatically stripped from the LRC output.
+
+- **Navidrome AudioMuse-AI Integration** *(contributed by [@cucadmuh](https://github.com/cucadmuh), PR [#147](https://github.com/Psychotoxical/psysonic/pull/147))*: Psysonic now  supports [AudioMuse-AI](https://github.com/cucadmuh/audiomuse-ai) if it is active on the Navidrome server and uses it for Random Mix, Similar Artists, and Instant Mix. No configuration required — Psysonic keeps its existing behavior when AudioMuse is unavailable. Also includes an Instant Mix probe, ping identity, and improved UX for AudioMuse-specific actions.
+
+- **ICY metadata & AzuraCast radio** *(contributed by [@sorensiimSalling](https://github.com/sorensiimSalling), PR [#146](https://github.com/Psychotoxical/psysonic/pull/146))*: Internet radio now displays live track metadata from ICY streams. AzuraCast stations are supported with extended now-playing information.
+
+- **Automatic audio device switching**: Psysonic now detects newly connected or changed audio output devices and switches to them automatically — no app restart required.
+
+### Fixed
+
+- **Multi-artist tracks**: Tracks with multiple artists (OpenSubsonic `artists[]` field, e.g. semicolon-separated entries) now display each artist individually. Artists with their own profile page are clickable links; artists without one appear as plain text. Separated by `·`.
+
+- **Gapless + Preload Gate**: The gapless chain and the preload gate now run on separate paths. Previously both could fire simultaneously, causing a brief black flash on track change.
+
+- **Replay Gain — missing album gain**: When no album gain tag is present, Psysonic now correctly falls back to track gain instead of skipping gain correction entirely.
+
+- **Statistics — music library scope**: Genre insights now respect the currently selected music library. Fetch results are cached to avoid redundant server requests. Playback durations are displayed in localized units.
+
+- **Russian locale**: "Most Played" in the sidebar, home page, and page title now uses «Популярное».
+
+### Changed
+
+- **"Reset to defaults" buttons** in Settings → Input are now styled as warning buttons (red border).
+- **Lyrics button** removed from the player bar (redundant with the queue panel tab).
+- **Icons**: Advanced search now uses the `TextSearch` icon; artist bio button now uses `Highlighter`.
+- **Album chip** in the album detail header is now opaque across all themes.
+- **Hot Cache and Hi-Res Audio**: Alpha badges removed — both features are production-ready.
+- **CPU optimisations**: Next-track buffering and preload settings have been consolidated into a unified control.
+
+### Theme Fixes
+
+- **Middle Earth**: Removed vertical stripe pattern from sidebar; improved queue artist contrast on hover; fixed album detail artist colour, bio text, and "Read more" link readability; "Next Tracks" divider label is now lighter.
+- **Toy Tale**: Fixed sidebar section labels (System/Library), queue tab buttons (Lyrics/Queue), inactive artist text, and "Next Tracks" divider label — all were too dark to read.
+- **Tetrastack**: Raised all purple and blue palette values (`#a020f0` → `#c070ff`, `#0060f0` → `#4090ff`); raised `--text-muted` from `#3a3a6a` to `#7878b8` — affected settings descriptions, artist names in tracklists, and queue labels.
+- **Horde & Alliance**: Removed repeating horizontal line pattern from sidebar.
+
+### Contributors
+
+Thank you to everyone who contributed to this release:
+
+- [@cucadmuh](https://github.com/cucadmuh) — AudioMuse-AI Navidrome integration (PR [#147](https://github.com/Psychotoxical/psysonic/pull/147))
+- [@sorensiimSalling](https://github.com/sorensiimSalling) — ICY metadata & AzuraCast radio support (PR [#146](https://github.com/Psychotoxical/psysonic/pull/146))
+
+You make Psysonic better. 🙌
+
+---
+
+## [1.34.7] - 2026-04-09
+
+### Added
+
+- **Windows — Taskbar Thumbnail Toolbar**: Prev / Play-Pause / Next media buttons now appear in the Windows taskbar thumbnail preview (the popup that appears when hovering over the taskbar icon). Buttons emit the same `media:*` events as the tray menu and souvlaki. The Play/Pause icon swaps in real-time as playback state changes.
+
+- **Windows — High-quality taskbar icons**: The taskbar thumbnail toolbar icons are now loaded from embedded `.ico` assets (`play.ico`, `pause.ico`, `prev.ico`, `next.ico`) via `CreateIconFromResourceEx`, replacing the previous monochrome GDI drawing code. All four icons are properly cleaned up on window destruction.
+
+- **Professional update modal**: The in-app updater now shows a polished modal with the full release changelog, a **Skip this version** option, and an OS-aware direct download button (`.dmg` on macOS, `.exe` on Windows, `.deb`/`.rpm` on Linux) as a fallback if the auto-update fails. The modal is fully localised in all 7 supported languages.
+
+- **Self-hosted fonts — no internet required**: All 10 UI fonts are now shipped as WOFF2 files bundled into the app via `@fontsource-variable` npm packages. The previous Google Fonts CDN dependency has been removed entirely — Psysonic now renders correctly with no internet connection and without any external requests on startup.
+
+- **Help — 11 new FAQ entries**: The Help page covers previously undocumented features across Ratings (how to rate songs/albums/artists, removing a rating, Skip-to-1★, rating filter for mixes), Folder Browser, Theme Scheduler, UI Scale, Seekbar styles, AutoEQ, Replay Gain, Hot Cache, and offline playlist caching. All 7 locales updated.
+
+### Fixed
+
+- **Embedded lyrics (MP3 & FLAC)**: A new `get_embedded_lyrics` Tauri command reads lyrics tags directly from local files — `SYLT`/`USLT` frames for MP3 (via the `id3` crate) and `SYNCEDLYRICS`/`LYRICS` tags for FLAC (via `lofty`). Additionally: the LRC parser now correctly handles timestamps without fractional seconds (e.g. `[01:23]`), and the Subsonic structured-lyrics parser now accepts both `synced` and `issynced` field names for compatibility with different server versions.
+
+- **Linux — player bar disappearing at high zoom / small window sizes**: All `grid-template-rows` definitions now use `minmax(0, 1fr)` instead of bare `1fr`, and the `min-height: 720px` constraint on the app shell has been removed. The player bar no longer gets pushed off-screen when the window is small or the UI scale is above 100 %.
+
+- **Windows — "Open folder" in Settings crashing**: The Settings page uses a Rust `open_folder` command instead of the Tauri `shell:open` API, which was blocked by the capability scope on Windows for local paths.
+
+- **macOS — Artist Radio crashing WKWebView after ~10 minutes**: Storing `currentTime` in the persisted Zustand state caused up to ~1,200 synchronous `localStorage.setItem` calls per radio session, eventually crashing the WKWebView SQLite backend. `currentTime` has been removed from the persist partializer. Old played radio tracks are also now trimmed from the queue (keeping the last 5) to cap the localStorage payload during queue top-up.
+
+- **Artist Radio — predictable track order**: The initial Artist Radio queue is now shuffled via Fisher-Yates, so positions 2+ draw from similar-artist tracks in a random order rather than always playing the server's top-5 tracks in sequence.
+
+- **Internet Radio — stall / buffering recovery**: Stall events on the HTML5 `<audio>` element now trigger automatic reconnection (up to 5 retries), recovering from transient network interruptions without requiring a manual restart.
+
+- **Corrupt MP3s — VLC-style frame tolerance**: The audio decoder now tolerates up to 100 consecutive bad frames before giving up (previously 3), matching VLC's behavior for files with invalid `main_data` offset frames. Frame-drop log messages are suppressed in release builds.
+
+- **Statistics — album/song totals respect selected music library**: Album and track counts on the Statistics page were previously derived from `getGenres()`, which is not scoped to the active music folder. Both counts are now derived from the same paginated `getAlbumList` pass used for playtime, with the same 5,000-album cap and a `≥` prefix when capped. *(PR [#138](https://github.com/Psychotoxical/psysonic/pull/138) by [@cucadmuh](https://github.com/cucadmuh))*
+
+- **Fullscreen — resize grips visible in native fullscreen**: Resize grips are now hidden whenever the window enters native fullscreen on all platforms (previously only tracked on Linux). An initial check on mount also catches windows that start in a maximized or fullscreen state.
+
+- **Albums page — year filter input height**: The "From year" / "To year" inputs in the Albums filter bar now match the height and font size of adjacent buttons, fixing the mixed-height row introduced in v1.34.4.
+
+- **Russian locale — missing lyrics-source strings**: The `lyricsServerFirst` and related settings strings were not translated in the Russian locale. *(PR [#140](https://github.com/Psychotoxical/psysonic/pull/140) by [@kilyabin](https://github.com/kilyabin))*
+
+### Contributors
+
+Thank you to everyone who contributed to this release:
+
+- [@cucadmuh](https://github.com/cucadmuh) — Statistics music-folder scope fix (PR [#138](https://github.com/Psychotoxical/psysonic/pull/138))
+- [@kilyabin](https://github.com/kilyabin) — Russian locale lyrics strings (PR [#140](https://github.com/Psychotoxical/psysonic/pull/140))
+
+---
+
+## [1.34.6] - 2026-04-08
+
+> I'm sorry this is already the third release today — every time we shipped a critical fix, another critical issue surfaced. Hopefully this one holds. 🤞
+
+### 🚨 Critical Fix
+
+- **ZIP downloads no longer freeze the UI**: All ZIP downloads (Album Detail, Playlist Detail, Albums, New Releases, Random Albums) previously buffered the entire file in the JS heap via `fetch + blob + arrayBuffer`, which caused the app to become completely unresponsive for large downloads (e.g. a 600-song, 7 GB playlist). Downloads now stream directly to disk via the Rust backend (`invoke('download_zip')`), matching the existing single-album download behavior. Progress is shown in the download overlay (bottom right).
+
+- **Offline cache downloads no longer freeze the UI**: Caching a large playlist (600+ songs) triggered up to ~1,200 synchronous `localStorage.setItem` calls as Zustand's `persist` middleware wrote on every state update. Transient download job state has been moved to a new non-persisted store (`offlineJobStore`), reducing localStorage writes for an entire download to **2** regardless of playlist size.
+
+### Added
+
+- **Playlist offline toggle**: When a playlist is already cached offline, clicking the cache button now removes it from the offline cache (shown with a red trash icon) instead of re-downloading it.
+
+### Fixed
+
+- **Home page — "Recently Added" section title** now links to `/new-releases` instead of `/albums`.
+
+---
+
+## [1.34.5] - 2026-04-08
+
+### 🚨 Critical Fix
+
+- **Massive API request flood fixed** *(closes [#133](https://github.com/Psychotoxical/psysonic/issues/133))*: Psysonic was generating 15,000+ background requests per day, filling reverse-proxy access logs (Traefik, nginx) and in some cases crashing the proxy entirely. Four root causes identified and resolved:
+  - **Now Playing polling**: Was firing every 10 seconds unconditionally — even when minimized or the dropdown was closed. Now only polls while the dropdown is open, and respects the Page Visibility API to pause immediately when the window is hidden.
+  - **Connection check interval**: Reduced from every 30 seconds to every **120 seconds** (4× reduction).
+  - **Queue sync debounce**: Increased from 1.5 s to **5 s**, preventing request bursts when skipping rapidly through tracks.
+  - **Rating prefetch cache**: Artist and album ratings are now cached in memory for **7 minutes**. Repeated page loads (Random Albums, Random Mix) no longer re-fetch ratings that were just retrieved.
+
+### Added
+
+- **Theme Scheduler** *(Settings → Appearance)*: Automatically switches the active theme at configurable times of day. Two time slots (e.g. a light theme during the day, a dark one at night). English locale displays hours in 12-hour AM/PM format; all other languages use 24-hour format.
+
+- **Theme Scheduler hint**: When the scheduler is active, a notice appears at the top of the Theme Picker explaining why manually selecting a theme has no immediate effect.
+
+- **UI Scale** *(Settings → Appearance)*: Adjust the global interface scale (80 % – 125 %) without changing the system font size.
+
+- **Folder Browser**: New sidebar section with Miller-columns directory navigation. Browse the server's music folder tree and play or queue folders directly.
+
+- **Seekbar — Waveform fade edges**: The Waveform seekbar style now fades out at both ends, giving it a cleaner, less abrupt look.
+
+- **Cover art fallback logo**: When a cover art image fails to load (broken URL, server error), the Psysonic logo is shown as a placeholder instead of a broken image icon.
+
+- **Tiling WM support** *(PR [#134](https://github.com/Psychotoxical/psysonic/pull/134))*: On tiling window managers (Hyprland, Sway, i3, bspwm, AwesomeWM, etc.) the custom title bar is automatically hidden — the WM manages window decorations. The title bar toggle in Settings is also hidden on tiling WMs. Detection is based on environment variables (`HYPRLAND_INSTANCE_SIGNATURE`, `SWAYSOCK`, `I3SOCK`, `XDG_CURRENT_DESKTOP`).
+
+### Changed
+
+- **Custom title bar disabled by default**: New installations start with the native OS title bar. Existing users keep their saved preference.
+
+### Fixed
+
+- **Custom title bar (Linux) — drag & resize**: Window dragging via the title bar now works correctly (missing Tauri `core:window:allow-start-dragging` capability was silently blocking it). CSS resize grips are now shown at the bottom corners to compensate for the removed native GTK grips. The title bar no longer misplaces itself when the window is resized to a small width (mobile-grid layout now includes the title bar row).
+
+- **Fullscreen Player — accent color delay**: The dynamic accent color extracted from album artwork now appears in ~200–300 ms instead of up to 18 seconds. The previous implementation queued the cover fetch behind up to 5 concurrent image loads via the app-wide image cache. It now fetches the cover directly and independently. The extracted color is also cached per cover ID, so switching between tracks on the same album is instant.
+
+- **Artist Detail page — slow initial render** *(closes [#132](https://github.com/Psychotoxical/psysonic/issues/132))*: Artist info and biography are now fetched independently of the main artist data, so the page renders immediately and the bio fades in once available. Previously, a slow `getArtistInfo` response blocked the entire page from rendering.
+
+- **Seekbar — Pulse Wave & Retro Tape styles**: Pulse Wave no longer leaves a stray connecting line at the playhead position. Retro Tape's rolling wheel is now anchored at the playhead instead of the center of the bar.
+
+- **Statistics — Top Rated Songs/Artists sections removed**: These sections were incorrectly added in v1.34.4 and have been removed. All other rating features from that release remain fully intact.
+
+---
+
+## [1.34.4] - 2026-04-08
+
+### Added
+
+- **Entity ratings** *(PR [#130](https://github.com/Psychotoxical/psysonic/pull/130))*: Full star-rating support (1–5 ★) for songs, albums, and artists via the OpenSubsonic `setRating` API. Ratings are shown and editable in the album track list, artist detail page, and the Favorites song list. A new shared `StarRating` component is used consistently across all surfaces. Requires an OpenSubsonic-compatible server (e.g. Navidrome ≥ 0.53).
+
+- **Song ratings — context menu & player bar**: Songs can additionally be rated directly from the **right-click context menu** and from the **player bar** (below the artist name), with optimistic updates reflected immediately across all views.
+
+- **Skip-to-1★** *(PR [#130](https://github.com/Psychotoxical/psysonic/pull/130))*: Automatically assigns a 1-star rating to a song after it has been manually skipped a configurable number of consecutive times. This skip count threshold can be enabled and adjusted in Settings → Ratings.
+
+- **Mix minimum rating filter** *(PR [#130](https://github.com/Psychotoxical/psysonic/pull/130))*: Random Mix and Home Quick Mix can now be filtered by minimum rating per entity type (song / album / artist). Configure thresholds in Settings → Ratings.
+
+- **Statistics — Top Rated Songs & Artists**: New "Top Rated Songs" and "Top Rated Artists" sections on the Statistics page, derived from starred items with a `userRating > 0`. Lists update live as ratings are changed without a page reload.
+
+- **Seekbar styles — 5 new styles**: Added Neon Glow, Pulse Wave, Particle Trail, Liquid Fill, and Retro Tape. Animated styles run a dedicated `requestAnimationFrame` loop. The style picker in Settings shows an animated live preview for each style.
+
+- **Custom title bar (Linux)**: Optional custom title bar with now-playing display (song title + artist, live-updating). Replaces the native GTK decoration when enabled. Automatically hides in native fullscreen (F11). Can be toggled in Settings → Appearance.
+
+- **Album multi-select**: Albums, New Releases, and Random Albums pages now support multi-select mode. Selected albums can be batch-queued or enqueued.
+
+- **Most Played — compilation filter**: New toggle on the Most Played page to hide compilation artists from the Top Artists list.
+
+- **Scroll reset on navigation**: The content area now scrolls back to the top automatically on every route change.
+
+### Fixed
+
+- **Backup**: The `psysonic_home` key is now included in the settings backup export.
+
+### i18n
+
+- New keys for seekbar styles, entity ratings, rating sections (Settings + Statistics), and entity rating support added to all 7 languages (EN, DE, FR, NL, ZH, NB, RU).
+
+---
+
+## [1.34.3] - 2026-04-07
+
+### Added
+
+- **Most Played page** *(closes [#86](https://github.com/Psychotoxical/psysonic/issues/86))*: New dedicated page accessible via the sidebar (TrendingUp icon, `/most-played`). Shows **Top Artists** (ranked by total play count, derived by aggregating album play counts per artist) and a paginated **Top Albums** list with cover art, play count, sort toggle (most/fewest first), and a Load More button.
+
+- **Playlist ZIP download** *(closes [#127](https://github.com/Psychotoxical/psysonic/issues/127))*: Download (ZIP) button in the playlist hero header — same UX as album download. Uses the Subsonic `/rest/download.view` endpoint with the playlist ID, shows a progress bar during transfer, and remembers the last used folder.
+
+- **Fullscreen Player — adaptive accent color**: Extracts the most vibrant pixel from the current album cover (8×8 Canvas downscale, max-HSL-saturation) and applies a WCAG 4.5:1-compliant accent as `--dynamic-fs-accent`. Song title, play button, seekbar, active states, background mesh blobs, and cover art glow all transition smoothly to the extracted color. Resets to the theme accent when the player closes.
+
+- **Dracula theme**: Added to the Open Source Classics group.
+
+- **Discord Rich Presence — Apple Music cover opt-in**: iTunes artwork lookup is now disabled by default. A new toggle in Settings → Integrations ("Fetch covers from Apple Music for Discord") must be explicitly enabled — it sends artist and album name to Apple's search API to find cover art for the Discord profile.
+
+- **Discord Rich Presence — Paused state**: When playback is paused, the Discord presence now shows "Paused" as the status text.
+
+### Fixed
+
+- **M4A playback — older iTunes-purchased files**: Files with an embedded MJPEG cover-art stream and an `iTunSMPB` gapless tag now play correctly. The Symphonia isomp4 patch skips malformed trak atoms gracefully; `parse_gapless_info` now searches for the `" 00000000 "` sentinel to skip the 16-byte binary `data`-atom header, correctly extracting encoder delay and total sample count.
+
+### i18n
+
+- New keys for the Most Played page, playlist download, and Discord Apple Music opt-in added to all 7 languages (EN, DE, FR, NL, ZH, NB, RU).
+
+---
+
 ## [1.34.2] - 2026-04-07
 
 ### Added

README.md

@@ -8,10 +8,14 @@
     <a href="https://github.com/Psychotoxical/psysonic/blob/main/LICENSE"><img alt="License: GPL v3" src="https://img.shields.io/badge/License-GPLv3-cba6f7?style=flat-square"></a>
     <a href="https://tauri.app/"><img alt="Built with Tauri" src="https://img.shields.io/badge/Built%20with-Tauri-242938?style=flat-square&logo=tauri"></a>
     <a href="https://aur.archlinux.org/packages/psysonic"><img alt="AUR" src="https://img.shields.io/aur/version/psysonic?style=flat-square&color=1793d1"></a>
+    <a href="https://aur.archlinux.org/packages/psysonic-bin"><img alt="AUR (bin)" src="https://img.shields.io/aur/version/psysonic-bin?style=flat-square&color=1793d1&label=AUR%20(bin)"></a>
     <a href="https://discord.gg/ckVPGPMS"><img alt="Discord" src="https://img.shields.io/badge/Discord-Join%20us-5865F2?style=flat-square&logo=discord&logoColor=white"></a>
   </p>
 </div>
 
+> [!WARNING]
+> **Psysonic is under heavy active development.** Bugs and rough edges are to be expected. We reserve the right to change, remove, or rework existing features at any time without prior notice.
+
 ---
 
 <div align="center">
@@ -28,27 +32,35 @@ Psysonic is a beautiful desktop music player built completely from the ground up
 Designed specifically for users hosting their own music via Navidrome or other Subsonic API servers, Psysonic aims to be the best way to interact with your personal library.
 
 
-![Psysonic Screenshot](public/screenshot.png)
+![Psysonic Screenshot](public/screenshot1.png)
 
 ## ✨ Features
 
-- 🎨 **Gorgeous UI**: A large selection of beautiful, lean themes for every taste — Open Source Classics (Catppuccin, Nord, Gruvbox, Nightfox), Operating Systems, Games, Movies, Series, Psysonic originals, and Mediaplayer — with smooth glassmorphism effects and micro-animations.
+- 🎨 **Gorgeous UI**: 67 beautiful themes across 8 groups — Open Source Classics (Catppuccin, Nord, Gruvbox, Nightfox, Dracula), Operating Systems, Games, Movies, Series, Social Media, Psysonic originals, and Mediaplayer — with smooth glassmorphism effects and micro-animations. A time-based **Theme Scheduler** can automatically switch between a day and night theme.
 - ⚡ **Blazing Fast**: Built with Rust & Tauri — native audio engine (rodio), minimal RAM usage compared to typical Electron apps.
-- 🌍 **Internationalization (i18n)**: Fully translated into English, German, French, Dutch, and Chinese.
+- 🌍 **Internationalization (i18n)**: Fully translated into English, German, French, Dutch, Chinese, Norwegian, and Russian.
 - 📻 **Live "Now Playing"**: See what other users on your server are currently listening to in real-time.
 - 🎵 **Last.fm Integration**: Direct scrobbling, Now Playing updates, love/unlove, Similar Artists, and top stats — no Navidrome configuration required.
-- 🎤 **Synchronized Lyrics**: In-sidebar lyrics pane powered by LRCLIB — synced with auto-scroll, line highlighting, click-to-seek, and plain-text fallback.
+- 🎤 **Synchronized Lyrics**: Lyrics pane in the sidebar and fullscreen player — powered by LRCLIB and your Navidrome server. Synced lyrics auto-scroll with line highlighting and click-to-seek; plain-text fallback for unsynced tracks.
 - 📻 **Smart Radio**: Start a Radio session from any song or artist. Playback begins instantly from top local tracks while similar artist tracks (via Last.fm) load in the background. Radio queues reload proactively so sessions never run dry.
 - ♾️ **Infinite Queue**: When the queue runs out with Repeat off, Psysonic silently appends more random tracks (optionally filtered by genre) so playback never stops. Auto-added tracks appear below a clear `— Auto —` divider.
+- 🎛️ **10-Band Graphic EQ**: Built-in EQ with presets and the ability to save custom presets. **AutoEQ** support lets you load headphone correction profiles automatically.
+- 🔀 **Gapless & Crossfade**: True gapless playback and configurable crossfade between tracks (mutually exclusive).
+- 📻 **Internet Radio**: Built-in internet radio player — browse and play any ICY/HLS stream directly within Psysonic.
+- ⭐ **Ratings**: Rate songs, albums, and artists with 1–5 stars via the context menu, player bar, or album detail view. Supports the OpenSubsonic ratings extension. Auto-rate-down songs you skip repeatedly (configurable threshold). Filter Random Mix and Random Albums by minimum star rating.
+- 🖥️ **Fullscreen Player**: A dedicated fullscreen view with album art, animated lyrics overlay, and artist image — toggled with a single click.
+- 📋 **Playlist Management**: Create, edit, rename, and delete playlists. Drag-and-drop track reordering, song search, and smart suggestions right inside the playlist view.
 - 💾 **IndexedDB Caching**: Ultra-fast loading times with persistent IndexedDB image caching for cover art and artist images.
 - 📀 **Album Downloads**: Support for downloading entire albums directly to your local machine.
-- 💿 **Album & Artist Views**: Beautiful grid displays and detailed artist pages with related albums and color-coded initial avatars for fast browsing.
-- 〰️ **Waveform Seekbar**: Canvas-based waveform with a blue-to-mauve gradient and glow effect — click or drag anywhere to seek.
+- 💿 **Album & Artist Views**: Beautiful grid displays, multi-select album actions, and detailed artist pages with related albums.
+- 〰️ **Multi-Style Seekbar**: 10 canvas-drawn seekbar styles — Waveform, Bar, Thick Bar, Segmented, Line+Dot, Neon, Pulse Wave, Particle Trail, Liquid Fill, and Retro Tape.
 - 🎛️ **Queue Management**: Drag & drop reordering, shuffle, playlist saving/loading, and server-side queue synchronization.
 - ⌨️ **Configurable Keybindings**: Rebind any playback action (play/pause, next, seek, volume…) directly in Settings.
-- 🔤 **Font Picker**: 10 UI fonts to choose from in Settings → Appearance.
+- 🔤 **Font Picker & UI Scale**: 10 UI fonts and a global zoom slider (80–150%) to match your display and taste.
 - 🎼 **Random Mix**: Generate a random playlist from your entire library. Filter by keyword or pick a Super Genre (Metal, Rock, Electronic, Jazz…) for a focused mix with progressive loading.
 - 🏷️ **Genres**: Browse your entire library by genre — coloured cards sorted by album count with a dedicated album view per genre. Multi-select genre filter available on Albums, New Releases, and Random Albums pages.
+- 🔔 **System Tray**: Minimize Psysonic to the system tray. Play/Pause, Prev, Next, and Show/Hide controls available from the tray icon.
+- 💾 **Backup & Restore**: Export and import all your settings, themes, and server profiles in one click.
 - 🔄 **In-App Auto-Update**: Checks for new releases on startup. macOS and Windows can install and relaunch directly in-app; Linux users get a link to the GitHub release page.
 - 🖥️ **Cross-Platform**: Available natively for Windows, macOS, and Linux (Arch AUR, .deb, .rpm).
 
@@ -57,30 +69,41 @@ Designed specifically for users hosting their own music via Navidrome or other S
 ### ✅ Completed
 - [x] Native Rust/rodio audio engine (replaces Howler.js)
 - [x] 10-band graphic EQ with built-in and custom presets
+- [x] AutoEQ — automatic headphone correction profile loader
 - [x] Crossfade between tracks
 - [x] Replay Gain (track + album mode)
 - [x] Gapless playback
-- [x] Waveform seekbar
+- [x] Multi-style seekbar (10 styles: Waveform, Bar, Thick, Segmented, Line+Dot, Neon, Pulse Wave, Particle Trail, Liquid Fill, Retro Tape)
 - [x] Last.fm scrobbling, Now Playing & love/unlove
 - [x] Similar Artists via Last.fm, filtered to library
-- [x] Statistics — Last.fm top charts & recent scrobbles
-- [x] Synchronized lyrics via LRCLIB (in-sidebar, auto-scroll, click-to-seek)
+- [x] Statistics — Last.fm top charts, recent scrobbles, top-rated songs & artists
+- [x] Synchronized lyrics via LRCLIB and Navidrome server (in-sidebar + fullscreen, auto-scroll, click-to-seek)
 - [x] Smart Radio with proactive queue loading
 - [x] Infinite Queue (random auto-fill when queue runs out)
 - [x] OGG/Vorbis native playback
+- [x] Internet Radio (ICY/HLS streams)
 - [x] In-app auto-updater (macOS + Windows)
 - [x] Multi-server support
 - [x] IndexedDB image caching
 - [x] Random Mix with server-native Genre Mix (top genres by song count, shuffleable)
 - [x] Advanced Search (text + genre + year + result-type filters)
-- [x] Large theme library across 8 groups: Open Source Classics, Operating Systems, Games, Movies, Series, Social Media, Psysonic originals, Mediaplayer
-- [x] Internationalization (English, German, French, Dutch, Chinese)
+- [x] 67 themes across 8 groups: Open Source Classics, Operating Systems, Games, Movies, Series, Social Media, Psysonic originals, Mediaplayer
+- [x] Time-based Theme Scheduler (auto day/night theme switching)
+- [x] Internationalization (English, German, French, Dutch, Chinese, Norwegian, Russian)
 - [x] AUR package (Arch / CachyOS)
 - [x] Configurable keybindings
-- [x] Font picker (10 UI fonts)
+- [x] Font picker (10 UI fonts) + global UI scale slider
+- [x] Playlist management (create, edit, delete, drag-and-drop reorder, suggestions)
+- [x] Fullscreen player with synced lyrics overlay
+- [x] System tray icon with playback controls
+- [x] Song / Album / Artist ratings (1–5 stars, OpenSubsonic extension)
+- [x] Auto-rate-down on repeated skips + minimum-rating filter for mixes
+- [x] Album multi-select actions
+- [x] Custom Linux titlebar
+- [x] Backup & Restore (settings export/import)
 
 ### 📋 Planned
-- [ ] Theme contrast & legibility audit — systematic review of text/background contrast ratios across all 60+ themes
+- [ ] Theme contrast & legibility audit — systematic review of text/background contrast ratios across all 67 themes
 - [ ] Accessibility (a11y) — keyboard navigation, screen reader support, ARIA labels
 - [ ] More languages
 

index.html

@@ -6,9 +6,6 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="description" content="Psysonic – Dein Navidrome Desktop Player" />
     <title>Psysonic</title>
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=Space+Grotesk:wght@400;500;600;700&display=swap" rel="stylesheet" />
   </head>
   <body>
     <div id="root"></div>

package-lock.json

@@ -1,13 +1,23 @@
 {
   "name": "psysonic",
-  "version": "1.30.0",
+  "version": "1.34.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "psysonic",
-      "version": "1.30.0",
+      "version": "1.34.8",
       "dependencies": {
+        "@fontsource-variable/dm-sans": "^5.2.8",
+        "@fontsource-variable/figtree": "^5.2.10",
+        "@fontsource-variable/inter": "^5.2.8",
+        "@fontsource-variable/lexend": "^5.2.11",
+        "@fontsource-variable/manrope": "^5.2.8",
+        "@fontsource-variable/nunito": "^5.2.7",
+        "@fontsource-variable/outfit": "^5.2.8",
+        "@fontsource-variable/plus-jakarta-sans": "^5.2.8",
+        "@fontsource-variable/rubik": "^5.2.8",
+        "@fontsource-variable/space-grotesk": "^5.2.10",
         "@tanstack/react-virtual": "^3.13.23",
         "@tauri-apps/api": "^2",
         "@tauri-apps/plugin-dialog": "^2.6.0",
@@ -36,7 +46,8 @@
         "@types/react-dom": "^18.3.1",
         "@vitejs/plugin-react": "^4.3.2",
         "typescript": "^5.5.3",
-        "vite": "^6.0.3"
+        "vite": "^6.0.3",
+        "vitest": "^4.1.3"
       }
     },
     "node_modules/@babel/code-frame": {
@@ -772,6 +783,96 @@
         "node": ">=18"
       }
     },
+    "node_modules/@fontsource-variable/dm-sans": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/dm-sans/-/dm-sans-5.2.8.tgz",
+      "integrity": "sha512-AxkvMTvNWgfrmlyjiV05vlHYJa+nRQCf1EfvIrQAPBpFJW0O9VTz7oAFr9S3lvbWdmnFoBk7yFqQL86u64nl2g==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource-variable/figtree": {
+      "version": "5.2.10",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/figtree/-/figtree-5.2.10.tgz",
+      "integrity": "sha512-a5Gumbpy3mdd+Yg31g6Qb7CmjYbrfyutJa3bWfP5q8A4GclIOwX7mI+ZuSHsJnw/mHvW6r9oh1AHJcJTIxK4JA==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource-variable/inter": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/inter/-/inter-5.2.8.tgz",
+      "integrity": "sha512-kOfP2D+ykbcX/P3IFnokOhVRNoTozo5/JxhAIVYLpea/UBmCQ/YWPBfWIDuBImXX/15KH+eKh4xpEUyS2sQQGQ==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource-variable/lexend": {
+      "version": "5.2.11",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/lexend/-/lexend-5.2.11.tgz",
+      "integrity": "sha512-0hgEQ4O7Nh8fxL/WWmspJf0BErbocRkZwtLRGey/V4mUUqxfF7QUwqhcdzwpjom3NYCniY4uzQ5wYD7r9/92tQ==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource-variable/manrope": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/manrope/-/manrope-5.2.8.tgz",
+      "integrity": "sha512-nc9lOuCRz73UHnovDE2bwXUdghE2SEOc7Aii0qGe3CLyE03W1a7VnY5Z6euRiapiKbCkGS+eXbY3s/kvWeGeSw==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource-variable/nunito": {
+      "version": "5.2.7",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/nunito/-/nunito-5.2.7.tgz",
+      "integrity": "sha512-2N8QhatkyKgSUbAGZO2FYLioxA32+RyI1EplVLawbpkGjUeui9Qg9VMrpkCaik1ydjFjfLV+kzQ0cGEsMrMenQ==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource-variable/outfit": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/outfit/-/outfit-5.2.8.tgz",
+      "integrity": "sha512-4oUDCZx/Tcz6HZP423w/niqEH31Gks5IsqHV2ZZz1qKHaVIZdj2f0/S1IK2n8jl6Xo0o3N+3RjNHlV9R73ozQA==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource-variable/plus-jakarta-sans": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/plus-jakarta-sans/-/plus-jakarta-sans-5.2.8.tgz",
+      "integrity": "sha512-iQecBizIdZxezODNHzOn4SvvRMrZL/S8k4MEXGDynCmUrImVW0VmX+tIAMqnADwH4haXlHSXqMgU6+kcfBQJdw==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource-variable/rubik": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/rubik/-/rubik-5.2.8.tgz",
+      "integrity": "sha512-vGDExLzB4a2Fj9mca5LqNoA2ZKcU9o+x5FEBLte/nxYkCB9hOQwZS6ZlItUv+Ssn7YMzKauGuI/Po+YueFuZbg==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource-variable/space-grotesk": {
+      "version": "5.2.10",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/space-grotesk/-/space-grotesk-5.2.10.tgz",
+      "integrity": "sha512-yJQO/o35/hAP3CFnpdFTwQku2yzJOae2HIpBmqkOVoxhhXJaQP3g+b6Jrz7u+eI7A5ZdCIf88uMWpBJdFiGr5w==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
     "node_modules/@jridgewell/gen-mapping": {
       "version": "0.3.13",
       "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
@@ -1227,6 +1328,13 @@
         "win32"
       ]
     },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@tanstack/react-virtual": {
       "version": "3.13.23",
       "resolved": "https://registry.npmjs.org/@tanstack/react-virtual/-/react-virtual-3.13.23.tgz",
@@ -1613,6 +1721,24 @@
         "@babel/types": "^7.28.2"
       }
     },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -1686,6 +1812,129 @@
         "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
       }
     },
+    "node_modules/@vitest/expect": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.3.tgz",
+      "integrity": "sha512-CW8Q9KMtXDGHj0vCsqui0M5KqRsu0zm0GNDW7Gd3U7nZ2RFpPKSCpeCXoT+/+5zr1TNlsoQRDEz+LzZUyq6gnQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.1.3",
+        "@vitest/utils": "4.1.3",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.3.tgz",
+      "integrity": "sha512-XN3TrycitDQSzGRnec/YWgoofkYRhouyVQj4YNsJ5r/STCUFqMrP4+oxEv3e7ZbLi4og5kIHrZwekDJgw6hcjw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "4.1.3",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.3.tgz",
+      "integrity": "sha512-hYqqwuMbpkkBodpRh4k4cQSOELxXky1NfMmQvOfKvV8zQHz8x8Dla+2wzElkMkBvSAJX5TRGHJAQvK0TcOafwg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.3.tgz",
+      "integrity": "sha512-VwgOz5MmT0KhlUj40h02LWDpUBVpflZ/b7xZFA25F29AJzIrE+SMuwzFf0b7t4EXdwRNX61C3B6auIXQTR3ttA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "4.1.3",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.3.tgz",
+      "integrity": "sha512-9l+k/J9KG5wPJDX9BcFFzhhwNjwkRb8RsnYhaT1vPY7OufxmQFc9sZzScRCPTiETzl37mrIWVY9zxzmdVeJwDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.3",
+        "@vitest/utils": "4.1.3",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.3.tgz",
+      "integrity": "sha512-ujj5Uwxagg4XUIfAUyRQxAg631BP6e9joRiN99mr48Bg9fRs+5mdUElhOoZ6rP5mBr8Bs3lmrREnkrQWkrsTCw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.3.tgz",
+      "integrity": "sha512-Pc/Oexse/khOWsGB+w3q4yzA4te7W4gpZZAvk+fr8qXfTURZUMj5i7kuxsNK5mP/dEB6ao3jfr0rs17fHhbHdw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.3",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/asynckit": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
@@ -1693,14 +1942,14 @@
       "license": "MIT"
     },
     "node_modules/axios": {
-      "version": "1.13.6",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.6.tgz",
-      "integrity": "sha512-ChTCHMouEe2kn713WHbQGcuYrr6fXTBiu460OTwWrWob16g1bXn4vtz07Ope7ewMozJAnEquLk5lWQWtBig9DQ==",
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.15.0.tgz",
+      "integrity": "sha512-wWyJDlAatxk30ZJer+GeCWS209sA42X+N5jU2jy6oHTp7ufw8uzUTVFBX9+wTfAlhiJXGS0Bq7X6efruWjuK9Q==",
       "license": "MIT",
       "dependencies": {
         "follow-redirects": "^1.15.11",
         "form-data": "^4.0.5",
-        "proxy-from-env": "^1.1.0"
+        "proxy-from-env": "^2.1.0"
       }
     },
     "node_modules/baseline-browser-mapping": {
@@ -1784,6 +2033,16 @@
       ],
       "license": "CC-BY-4.0"
     },
+    "node_modules/chai": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/charenc": {
       "version": "0.0.2",
       "resolved": "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz",
@@ -1894,6 +2153,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es-module-lexer": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.0.0.tgz",
+      "integrity": "sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/es-object-atoms": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
@@ -1973,6 +2239,26 @@
         "node": ">=6"
       }
     },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "node_modules/expect-type": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
+      "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/fdir": {
       "version": "6.5.0",
       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
@@ -2258,6 +2544,16 @@
         "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0-rc"
       }
     },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -2332,6 +2628,24 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/obug": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
+      "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT"
+    },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -2382,10 +2696,13 @@
       }
     },
     "node_modules/proxy-from-env": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
-      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
-      "license": "MIT"
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
+      "integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
     },
     "node_modules/react": {
       "version": "18.3.1",
@@ -2545,6 +2862,13 @@
         "semver": "bin/semver.js"
       }
     },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/source-map-js": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
@@ -2555,6 +2879,37 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/std-env": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.0.0.tgz",
+      "integrity": "sha512-zUMPtQ/HBY3/50VbpkupYHbRroTRZJPRLvreamgErJVys0ceuzMkD44J/QjqhHjOzK42GQ3QZIeFG1OYfOtKqQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.1.1.tgz",
+      "integrity": "sha512-VKS/ZaQhhkKFMANmAOhhXVoIfBXblQxGX1myCQ2faQrfmobMftXeJPcZGp0gS07ocvGJWDLZGyOZDadDBqYIJg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/tinyglobby": {
       "version": "0.2.15",
       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
@@ -2572,6 +2927,16 @@
         "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
+    "node_modules/tinyrainbow": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.0.tgz",
+      "integrity": "sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
     "node_modules/typescript": {
       "version": "5.9.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
@@ -2634,9 +2999,9 @@
       }
     },
     "node_modules/vite": {
-      "version": "6.4.1",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
-      "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
+      "version": "6.4.2",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.2.tgz",
+      "integrity": "sha512-2N/55r4JDJ4gdrCvGgINMy+HH3iRpNIz8K6SFwVsA+JbQScLiC+clmAxBgwiSPgcG9U15QmvqCGWzMbqda5zGQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2708,6 +3073,96 @@
         }
       }
     },
+    "node_modules/vitest": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.3.tgz",
+      "integrity": "sha512-DBc4Tx0MPNsqb9isoyOq00lHftVx/KIU44QOm2q59npZyLUkENn8TMFsuzuO+4U2FUa9rgbbPt3udrP25GcjXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.1.3",
+        "@vitest/mocker": "4.1.3",
+        "@vitest/pretty-format": "4.1.3",
+        "@vitest/runner": "4.1.3",
+        "@vitest/snapshot": "4.1.3",
+        "@vitest/spy": "4.1.3",
+        "@vitest/utils": "4.1.3",
+        "es-module-lexer": "^2.0.0",
+        "expect-type": "^1.3.0",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^4.0.0-rc.1",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.1.0",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.1.3",
+        "@vitest/browser-preview": "4.1.3",
+        "@vitest/browser-webdriverio": "4.1.3",
+        "@vitest/coverage-istanbul": "4.1.3",
+        "@vitest/coverage-v8": "4.1.3",
+        "@vitest/ui": "4.1.3",
+        "happy-dom": "*",
+        "jsdom": "*",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/coverage-istanbul": {
+          "optional": true
+        },
+        "@vitest/coverage-v8": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        },
+        "vite": {
+          "optional": false
+        }
+      }
+    },
     "node_modules/void-elements": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/void-elements/-/void-elements-3.1.0.tgz",
@@ -2717,6 +3172,23 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/yallist": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "psysonic",
-  "version": "1.34.2",
+  "version": "1.34.8",
   "private": true,
   "scripts": {
     "dev": "vite",
@@ -8,9 +8,20 @@
     "preview": "vite preview",
     "tauri": "tauri",
     "tauri:dev": "GDK_BACKEND=x11 WEBKIT_DISABLE_COMPOSITING_MODE=1 tauri dev",
-    "tauri:build": "tauri build"
+    "tauri:build": "tauri build",
+    "test": "vitest run"
   },
   "dependencies": {
+    "@fontsource-variable/dm-sans": "^5.2.8",
+    "@fontsource-variable/figtree": "^5.2.10",
+    "@fontsource-variable/inter": "^5.2.8",
+    "@fontsource-variable/lexend": "^5.2.11",
+    "@fontsource-variable/manrope": "^5.2.8",
+    "@fontsource-variable/nunito": "^5.2.7",
+    "@fontsource-variable/outfit": "^5.2.8",
+    "@fontsource-variable/plus-jakarta-sans": "^5.2.8",
+    "@fontsource-variable/rubik": "^5.2.8",
+    "@fontsource-variable/space-grotesk": "^5.2.10",
     "@tanstack/react-virtual": "^3.13.23",
     "@tauri-apps/api": "^2",
     "@tauri-apps/plugin-dialog": "^2.6.0",
@@ -39,6 +50,7 @@
     "@types/react-dom": "^18.3.1",
     "@vitejs/plugin-react": "^4.3.2",
     "typescript": "^5.5.3",
-    "vite": "^6.0.3"
+    "vite": "^6.0.3",
+    "vitest": "^4.1.3"
   }
 }

packages/aur/PKGBUILD

@@ -1,6 +1,6 @@
 # Maintainer: Psychotoxic <psychotoxic@gmx.de>
 pkgname=psysonic
-pkgver=1.34.1
+pkgver=1.34.8
 pkgrel=1
 pkgdesc="Desktop music player for Subsonic API-compatible servers (Navidrome, Gonic, etc.)"
 arch=('x86_64')
@@ -28,7 +28,7 @@ build() {
   export CARGO_HOME="$srcdir/cargo-home"
   export npm_config_cache="$srcdir/npm-cache"
 
-  # ring (used by tauri-plugin-updater → rustls) ships C/asm objects whose
+  # ring (used by reqwest → rustls-tls) ships C/asm objects whose
   # symbols (ring_core_*) lld cannot resolve.  On Arch/CachyOS, -fuse-ld=lld
   # is hardcoded into rustc itself (not just makepkg.conf RUSTFLAGS), so a
   # string substitution is a no-op.  Appending -C link-arg=-fuse-ld=bfd works

src-tauri/Cargo.lock

@@ -907,6 +907,12 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 
+[[package]]
+name = "data-encoding"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
+
 [[package]]
 name = "deranged"
 version = "0.5.8"
@@ -2058,6 +2064,17 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
 
+[[package]]
+name = "id3"
+version = "1.16.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "965c5e6a62a241f2f673df956ea5f52c27780bc1031855890a551ed9b869e2d1"
+dependencies = [
+ "bitflags 2.11.0",
+ "byteorder",
+ "flate2",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -2420,6 +2437,32 @@ dependencies = [
  "scopeguard",
 ]
 
+[[package]]
+name = "lofty"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca260c51a9c71f823fbfd2e6fbc8eb2ee09834b98c00763d877ca8bfa85cde3e"
+dependencies = [
+ "byteorder",
+ "data-encoding",
+ "flate2",
+ "lofty_attr",
+ "log",
+ "ogg_pager",
+ "paste",
+]
+
+[[package]]
+name = "lofty_attr"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed9983e64b2358522f745c1251924e3ab7252d55637e80f6a0a3de642d6a9efc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "log"
 version = "0.4.29"
@@ -2881,6 +2924,15 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "ogg_pager"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d6d1ca8364b84e0cf725eed06b1460c44671e6c0fb28765f5262de3ece07fdc"
+dependencies = [
+ "byteorder",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.21.3"
@@ -2979,6 +3031,12 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
 [[package]]
 name = "pathdiff"
 version = "0.2.3"
@@ -3339,11 +3397,13 @@ dependencies = [
 
 [[package]]
 name = "psysonic"
-version = "1.34.1"
+version = "1.34.7"
 dependencies = [
  "biquad",
  "discord-rich-presence",
  "futures-util",
+ "id3",
+ "lofty",
  "md5",
  "reqwest 0.12.28",
  "ringbuf",
@@ -3365,6 +3425,7 @@ dependencies = [
  "thread-priority",
  "tokio",
  "url",
+ "windows 0.58.0",
 ]
 
 [[package]]
@@ -4504,8 +4565,6 @@ dependencies = [
 [[package]]
 name = "symphonia-format-isomp4"
 version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243739585d11f81daf8dac8d9f3d18cc7898f6c09a259675fc364b382c30e0a5"
 dependencies = [
  "encoding_rs",
  "log",
@@ -5867,8 +5926,8 @@ dependencies = [
  "webview2-com-sys",
  "windows 0.61.3",
  "windows-core 0.61.2",
- "windows-implement",
- "windows-interface",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
 ]
 
 [[package]]
@@ -5958,6 +6017,16 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
+dependencies = [
+ "windows-core 0.58.0",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows"
 version = "0.61.3"
@@ -5990,14 +6059,27 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-core"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
+dependencies = [
+ "windows-implement 0.58.0",
+ "windows-interface 0.58.0",
+ "windows-result 0.2.0",
+ "windows-strings 0.1.0",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
 dependencies = [
- "windows-implement",
- "windows-interface",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
  "windows-link 0.1.3",
  "windows-result 0.3.4",
  "windows-strings 0.4.2",
@@ -6009,8 +6091,8 @@ version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
- "windows-implement",
- "windows-interface",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
  "windows-link 0.2.1",
  "windows-result 0.4.1",
  "windows-strings 0.5.1",
@@ -6027,6 +6109,17 @@ dependencies = [
  "windows-threading",
 ]
 
+[[package]]
+name = "windows-implement"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "windows-implement"
 version = "0.60.2"
@@ -6038,6 +6131,17 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "windows-interface"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "windows-interface"
 version = "0.59.3"
@@ -6080,6 +6184,15 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-result"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.3.4"
@@ -6098,6 +6211,16 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "windows-strings"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
+dependencies = [
+ "windows-result 0.2.0",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-strings"
 version = "0.4.2"

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "psysonic"
-version = "1.34.2"
+version = "1.34.8"
 description = "Psysonic Desktop Music Player"
 authors = []
 license = ""
@@ -35,7 +35,7 @@ symphonia = { version = "0.5", default-features = false, features = ["flac", "mp
 reqwest = { version = "0.12", default-features = false, features = ["stream", "json", "multipart", "rustls-tls", "blocking"] }
 futures-util = "0.3"
 md5 = "0.7"
-tokio = { version = "1", features = ["rt", "time"] }
+tokio = { version = "1", features = ["rt", "time", "sync"] }
 biquad = "0.4"
 ringbuf = "0.3"
 tauri-plugin-window-state = "2.4.1"
@@ -44,3 +44,24 @@ souvlaki = { version = "0.8", default-features = false, features = ["use_zbus"]
 discord-rich-presence = "0.2"
 url = "2"
 thread-priority = "1"
+lofty = "0.22"
+id3 = "1.16.4"
+
+[target.'cfg(windows)'.dependencies]
+windows = { version = "0.58", features = [
+    "Win32_Foundation",
+    "Win32_Graphics",
+    "Win32_Graphics_Gdi",
+    "Win32_System_Com",
+    "Win32_UI_Controls",
+    "Win32_UI_Shell",
+    "Win32_UI_WindowsAndMessaging",
+] }
+
+[patch.crates-io]
+# Local patch for Symphonia's isomp4 demuxer:
+# - Fixes descriptor.unwrap() panic on malformed esds atoms (older iTunes M4A)
+# - Tolerates SL predefined=0x01 (null) used by some older iTunes-purchased files
+# - Gracefully skips malformed trak atoms (e.g. MJPEG cover-art streams) instead
+#   of failing the entire probe
+symphonia-format-isomp4 = { path = "patches/symphonia-format-isomp4" }

src-tauri/capabilities/default.json

@@ -28,10 +28,13 @@
     "window-state:allow-restore-state",
     "core:window:allow-set-title",
     "core:window:allow-close",
+    "core:window:allow-minimize",
+    "core:window:allow-toggle-maximize",
     "core:window:allow-hide",
     "core:window:allow-show",
     "core:window:allow-set-fullscreen",
     "core:window:allow-is-fullscreen",
+    "core:window:allow-start-dragging",
     "core:window:allow-create",
     "core:webview:allow-create-webview-window",
     "process:allow-restart"

src-tauri/gen/schemas/capabilities.json

@@ -1 +1 @@
-{"default":{"identifier":"default","description":"Default capabilities for Psysonic","local":true,"windows":["main"],"permissions":["core:default","shell:default",{"identifier":"shell:allow-open","allow":[{"url":"https://**"}]},"global-shortcut:allow-register","global-shortcut:allow-unregister","store:default","store:allow-load","store:allow-set","store:allow-get","store:allow-save","dialog:default","dialog:allow-open","dialog:allow-save","fs:default","fs:allow-write-file","fs:allow-read-file","fs:allow-mkdir","fs:scope-download-recursive","fs:scope-home-recursive","window-state:allow-save-window-state","window-state:allow-restore-state","core:window:allow-set-title","core:window:allow-close","core:window:allow-hide","core:window:allow-show","core:window:allow-set-fullscreen","core:window:allow-is-fullscreen","core:window:allow-create","core:webview:allow-create-webview-window","process:allow-restart"],"platforms":["linux","macOS","windows"]}}
+{"default":{"identifier":"default","description":"Default capabilities for Psysonic","local":true,"windows":["main"],"permissions":["core:default","shell:default",{"identifier":"shell:allow-open","allow":[{"url":"https://**"}]},"global-shortcut:allow-register","global-shortcut:allow-unregister","store:default","store:allow-load","store:allow-set","store:allow-get","store:allow-save","dialog:default","dialog:allow-open","dialog:allow-save","fs:default","fs:allow-write-file","fs:allow-read-file","fs:allow-mkdir","fs:scope-download-recursive","fs:scope-home-recursive","window-state:allow-save-window-state","window-state:allow-restore-state","core:window:allow-set-title","core:window:allow-close","core:window:allow-minimize","core:window:allow-toggle-maximize","core:window:allow-hide","core:window:allow-show","core:window:allow-set-fullscreen","core:window:allow-is-fullscreen","core:window:allow-start-dragging","core:window:allow-create","core:webview:allow-create-webview-window","process:allow-restart"],"platforms":["linux","macOS","windows"]}}

src-tauri/patches/symphonia-format-isomp4/.cargo-ok

@@ -0,0 +1 @@
+{"v":1}

src-tauri/patches/symphonia-format-isomp4/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "6d533f26150953a882a6a111ebd13f0abf7129d5"
+  },
+  "path_in_vcs": "symphonia-format-isomp4"
+}

src-tauri/patches/symphonia-format-isomp4/Cargo.lock

@@ -0,0 +1,94 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bytemuck"
+version = "1.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3995eaeebcdf32f91f980d360f78732ddc061097ab4e39991ae7a6ace9194677"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "log"
+version = "0.4.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+
+[[package]]
+name = "symphonia-core"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea00cc4f79b7f6bb7ff87eddc065a1066f3a43fe1875979056672c9ef948c2af"
+dependencies = [
+ "arrayvec",
+ "bitflags",
+ "bytemuck",
+ "lazy_static",
+ "log",
+]
+
+[[package]]
+name = "symphonia-format-isomp4"
+version = "0.5.5"
+dependencies = [
+ "encoding_rs",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+ "symphonia-utils-xiph",
+]
+
+[[package]]
+name = "symphonia-metadata"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36306ff42b9ffe6e5afc99d49e121e0bd62fe79b9db7b9681d48e29fa19e6b16"
+dependencies = [
+ "encoding_rs",
+ "lazy_static",
+ "log",
+ "symphonia-core",
+]
+
+[[package]]
+name = "symphonia-utils-xiph"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27c85ab799a338446b68eec77abf42e1a6f1bb490656e121c6e27bfbab9f16"
+dependencies = [
+ "symphonia-core",
+ "symphonia-metadata",
+]

src-tauri/patches/symphonia-format-isomp4/Cargo.toml

@@ -0,0 +1,59 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+rust-version = "1.53"
+name = "symphonia-format-isomp4"
+version = "0.5.5"
+authors = ["Philip Deljanov <philip.deljanov@gmail.com>"]
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Pure Rust ISO/MP4 demuxer (a part of project Symphonia)."
+homepage = "https://github.com/pdeljanov/Symphonia"
+readme = "README.md"
+keywords = [
+    "audio",
+    "media",
+    "demuxer",
+    "mp4",
+    "iso",
+]
+categories = [
+    "multimedia",
+    "multimedia::audio",
+    "multimedia::encoding",
+]
+license = "MPL-2.0"
+repository = "https://github.com/pdeljanov/Symphonia"
+
+[lib]
+name = "symphonia_format_isomp4"
+path = "src/lib.rs"
+
+[dependencies.encoding_rs]
+version = "0.8.17"
+
+[dependencies.log]
+version = "0.4"
+
+[dependencies.symphonia-core]
+version = "0.5.5"
+
+[dependencies.symphonia-metadata]
+version = "0.5.5"
+
+[dependencies.symphonia-utils-xiph]
+version = "0.5.5"

src-tauri/patches/symphonia-format-isomp4/Cargo.toml.orig

@@ -0,0 +1,20 @@
+[package]
+name = "symphonia-format-isomp4"
+version = "0.5.5"
+description = "Pure Rust ISO/MP4 demuxer (a part of project Symphonia)."
+homepage = "https://github.com/pdeljanov/Symphonia"
+repository = "https://github.com/pdeljanov/Symphonia"
+authors = ["Philip Deljanov <philip.deljanov@gmail.com>"]
+license = "MPL-2.0"
+readme = "README.md"
+categories = ["multimedia", "multimedia::audio", "multimedia::encoding"]
+keywords = ["audio", "media", "demuxer", "mp4", "iso"]
+edition = "2018"
+rust-version = "1.53"
+
+[dependencies]
+encoding_rs = "0.8.17"
+log = "0.4"
+symphonia-core = { version = "0.5.5", path = "../symphonia-core" }
+symphonia-metadata = { version = "0.5.5", path = "../symphonia-metadata" }
+symphonia-utils-xiph = { version = "0.5.5", path = "../symphonia-utils-xiph" }

src-tauri/patches/symphonia-format-isomp4/README.md

@@ -0,0 +1,15 @@
+# Symphonia ISO/MP4 Demuxer
+
+[![Docs](https://docs.rs/symphonia-format-isomp4/badge.svg)](https://docs.rs/symphonia-format-isomp4)
+
+ISO/MP4 demuxer for Project Symphonia.
+
+**Note:** This crate is part of Project Symphonia. Please use the [`symphonia`](https://crates.io/crates/symphonia) crate instead of this one directly.
+
+## License
+
+Symphonia is provided under the MPL v2.0 license. Please refer to the LICENSE file for more details.
+
+## Contributing
+
+Symphonia is a free and open-source project that welcomes contributions! To get started, please read our [Contribution Guidelines](https://github.com/pdeljanov/Symphonia/tree/master/CONTRIBUTING.md).

src-tauri/patches/symphonia-format-isomp4/src/atoms/alac.rs

@@ -0,0 +1,60 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::codecs::{CodecParameters, CODEC_TYPE_ALAC};
+use symphonia_core::errors::{decode_error, unsupported_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct AlacAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// ALAC extra data (magic cookie).
+    extra_data: Box<[u8]>,
+}
+
+impl Atom for AlacAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (version, flags) = AtomHeader::read_extra(reader)?;
+
+        if version != 0 {
+            return unsupported_error("isomp4 (alac): unsupported alac version");
+        }
+
+        if flags != 0 {
+            return decode_error("isomp4 (alac): flags not zero");
+        }
+
+        if header.data_len <= AtomHeader::EXTRA_DATA_SIZE {
+            return decode_error("isomp4 (alac): invalid alac atom length");
+        }
+
+        // The ALAC magic cookie (aka extra data) is either 24 or 48 bytes long.
+        let magic_len = match header.data_len - AtomHeader::EXTRA_DATA_SIZE {
+            len @ 24 | len @ 48 => len as usize,
+            _ => return decode_error("isomp4 (alac): invalid magic cookie length"),
+        };
+
+        // Read the magic cookie.
+        let extra_data = reader.read_boxed_slice_exact(magic_len)?;
+
+        Ok(AlacAtom { header, extra_data })
+    }
+}
+
+impl AlacAtom {
+    pub fn fill_codec_params(&self, codec_params: &mut CodecParameters) {
+        codec_params.for_codec(CODEC_TYPE_ALAC).with_extra_data(self.extra_data.clone());
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/co64.rs

@@ -0,0 +1,41 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+/// Chunk offset atom (64-bit version).
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct Co64Atom {
+    /// Atom header.
+    header: AtomHeader,
+    pub chunk_offsets: Vec<u64>,
+}
+
+impl Atom for Co64Atom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        let entry_count = reader.read_be_u32()?;
+
+        // TODO: Apply a limit.
+        let mut chunk_offsets = Vec::with_capacity(entry_count as usize);
+
+        for _ in 0..entry_count {
+            chunk_offsets.push(reader.read_be_u64()?);
+        }
+
+        Ok(Co64Atom { header, chunk_offsets })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/ctts.rs

@@ -0,0 +1,29 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+/// Composition time atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct CttsAtom {
+    /// Atom header.
+    header: AtomHeader,
+}
+
+impl Atom for CttsAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(_reader: &mut B, _header: AtomHeader) -> Result<Self> {
+        todo!()
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/edts.rs

@@ -0,0 +1,43 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType, ElstAtom};
+
+/// Edits atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct EdtsAtom {
+    header: AtomHeader,
+    pub elst: Option<ElstAtom>,
+}
+
+impl Atom for EdtsAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    #[allow(clippy::single_match)]
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut elst = None;
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::EditList => {
+                    elst = Some(iter.read_atom::<ElstAtom>()?);
+                }
+                _ => (),
+            }
+        }
+
+        Ok(EdtsAtom { header, elst })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/elst.rs

@@ -0,0 +1,71 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+use symphonia_core::util::bits;
+
+use crate::atoms::{Atom, AtomHeader};
+
+/// Edit list entry.
+#[derive(Debug)]
+#[allow(dead_code)]
+pub struct ElstEntry {
+    segment_duration: u64,
+    media_time: i64,
+    media_rate_int: i16,
+    media_rate_frac: i16,
+}
+
+/// Edit list atom.
+#[derive(Debug)]
+#[allow(dead_code)]
+pub struct ElstAtom {
+    header: AtomHeader,
+    entries: Vec<ElstEntry>,
+}
+
+impl Atom for ElstAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (version, _) = AtomHeader::read_extra(reader)?;
+
+        // TODO: Apply a limit.
+        let entry_count = reader.read_be_u32()?;
+
+        let mut entries = Vec::new();
+
+        for _ in 0..entry_count {
+            let (segment_duration, media_time) = match version {
+                0 => (
+                    u64::from(reader.read_be_u32()?),
+                    i64::from(bits::sign_extend_leq32_to_i32(reader.read_be_u32()?, 32)),
+                ),
+                1 => (
+                    reader.read_be_u64()?,
+                    bits::sign_extend_leq64_to_i64(reader.read_be_u64()?, 64),
+                ),
+                _ => return decode_error("isomp4: invalid tkhd version"),
+            };
+
+            let media_rate_int = bits::sign_extend_leq16_to_i16(reader.read_be_u16()?, 16);
+            let media_rate_frac = bits::sign_extend_leq16_to_i16(reader.read_be_u16()?, 16);
+
+            entries.push(ElstEntry {
+                segment_duration,
+                media_time,
+                media_rate_int,
+                media_rate_frac,
+            });
+        }
+
+        Ok(ElstAtom { header, entries })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/esds.rs

@@ -0,0 +1,368 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::codecs::{
+    CodecParameters, CodecType, CODEC_TYPE_AAC, CODEC_TYPE_MP3, CODEC_TYPE_NULL,
+};
+use symphonia_core::errors::{decode_error, unsupported_error, Result};
+use symphonia_core::io::{FiniteStream, ReadBytes, ScopedStream};
+
+use crate::atoms::{Atom, AtomHeader};
+
+use log::{debug, warn};
+
+const ES_DESCRIPTOR: u8 = 0x03;
+const DECODER_CONFIG_DESCRIPTOR: u8 = 0x04;
+const DECODER_SPECIFIC_DESCRIPTOR: u8 = 0x05;
+const SL_CONFIG_DESCRIPTOR: u8 = 0x06;
+
+const MIN_DESCRIPTOR_SIZE: u64 = 2;
+
+fn read_descriptor_header<B: ReadBytes>(reader: &mut B) -> Result<(u8, u32)> {
+    let tag = reader.read_u8()?;
+
+    let mut size = 0;
+
+    for _ in 0..4 {
+        let val = reader.read_u8()?;
+        size = (size << 7) | u32::from(val & 0x7f);
+        if val & 0x80 == 0 {
+            break;
+        }
+    }
+
+    Ok((tag, size))
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct EsdsAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Elementary stream descriptor.
+    descriptor: ESDescriptor,
+}
+
+impl Atom for EsdsAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        let mut descriptor = None;
+
+        let mut scoped = ScopedStream::new(reader, header.data_len - AtomHeader::EXTRA_DATA_SIZE);
+
+        while scoped.bytes_available() > MIN_DESCRIPTOR_SIZE {
+            let (desc, desc_len) = read_descriptor_header(&mut scoped)?;
+
+            match desc {
+                ES_DESCRIPTOR => {
+                    descriptor = Some(ESDescriptor::read(&mut scoped, desc_len)?);
+                }
+                _ => {
+                    warn!("unknown descriptor in esds atom, desc={}", desc);
+                    scoped.ignore_bytes(desc_len as u64)?;
+                }
+            }
+        }
+
+        // Ignore remainder of the atom.
+        scoped.ignore()?;
+
+        // Guard against malformed esds atoms that contain no ES_DESCRIPTOR (old iTunes files).
+        let descriptor = descriptor
+            .ok_or_else(|| symphonia_core::errors::Error::DecodeError("isomp4: missing es descriptor in esds atom"))?;
+
+        Ok(EsdsAtom { header, descriptor })
+    }
+}
+
+impl EsdsAtom {
+    pub fn fill_codec_params(&self, codec_params: &mut CodecParameters) {
+        codec_params.for_codec(self.descriptor.dec_config.codec_type);
+
+        if let Some(ds_config) = &self.descriptor.dec_config.dec_specific_info {
+            codec_params.with_extra_data(ds_config.extra_data.clone());
+        }
+    }
+}
+
+pub trait ObjectDescriptor: Sized {
+    fn read<B: ReadBytes>(reader: &mut B, len: u32) -> Result<Self>;
+}
+
+/*
+class ES_Descriptor extends BaseDescriptor : bit(8) tag=ES_DescrTag {
+    bit(16) ES_ID;
+    bit(1) streamDependenceFlag;
+    bit(1) URL_Flag;
+    bit(1) OCRstreamFlag;
+    bit(5) streamPriority;
+    if (streamDependenceFlag)
+        bit(16) dependsOn_ES_ID;
+    if (URL_Flag) {
+        bit(8) URLlength;
+        bit(8) URLstring[URLlength];
+    }
+    if (OCRstreamFlag)
+        bit(16) OCR_ES_Id;
+    DecoderConfigDescriptor decConfigDescr;
+    SLConfigDescriptor slConfigDescr;
+    IPI_DescrPointer ipiPtr[0 .. 1];
+    IP_IdentificationDataSet ipIDS[0 .. 255];
+    IPMP_DescriptorPointer ipmpDescrPtr[0 .. 255];
+    LanguageDescriptor langDescr[0 .. 255];
+    QoS_Descriptor qosDescr[0 .. 1];
+    RegistrationDescriptor regDescr[0 .. 1];
+    ExtensionDescriptor extDescr[0 .. 255];
+}
+*/
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct ESDescriptor {
+    pub es_id: u16,
+    pub dec_config: DecoderConfigDescriptor,
+    pub sl_config: SLDescriptor,
+}
+
+impl ObjectDescriptor for ESDescriptor {
+    fn read<B: ReadBytes>(reader: &mut B, len: u32) -> Result<Self> {
+        let es_id = reader.read_be_u16()?;
+        let es_flags = reader.read_u8()?;
+
+        // Stream dependence flag.
+        if es_flags & 0x80 != 0 {
+            let _depends_on_es_id = reader.read_u16()?;
+        }
+
+        // URL flag.
+        if es_flags & 0x40 != 0 {
+            let url_len = reader.read_u8()?;
+            reader.ignore_bytes(u64::from(url_len))?;
+        }
+
+        // OCR stream flag.
+        if es_flags & 0x20 != 0 {
+            let _ocr_es_id = reader.read_u16()?;
+        }
+
+        let mut dec_config = None;
+        let mut sl_config = None;
+
+        let mut scoped = ScopedStream::new(reader, u64::from(len) - 3);
+
+        // Multiple descriptors follow, but only the decoder configuration descriptor is useful.
+        while scoped.bytes_available() > MIN_DESCRIPTOR_SIZE {
+            let (desc, desc_len) = read_descriptor_header(&mut scoped)?;
+
+            match desc {
+                DECODER_CONFIG_DESCRIPTOR => {
+                    dec_config = Some(DecoderConfigDescriptor::read(&mut scoped, desc_len)?);
+                }
+                SL_CONFIG_DESCRIPTOR => {
+                    sl_config = Some(SLDescriptor::read(&mut scoped, desc_len)?);
+                }
+                _ => {
+                    debug!("skipping {} object in es descriptor", desc);
+                    scoped.ignore_bytes(u64::from(desc_len))?;
+                }
+            }
+        }
+
+        // Consume remaining bytes.
+        scoped.ignore()?;
+
+        // Decoder configuration descriptor is mandatory.
+        if dec_config.is_none() {
+            return decode_error("isomp4: missing decoder config descriptor");
+        }
+
+        // SL descriptor is mandatory.
+        if sl_config.is_none() {
+            return decode_error("isomp4: missing sl config descriptor");
+        }
+
+        Ok(ESDescriptor { es_id, dec_config: dec_config.unwrap(), sl_config: sl_config.unwrap() })
+    }
+}
+
+/*
+class DecoderConfigDescriptor extends BaseDescriptor : bit(8) tag=DecoderConfigDescrTag {
+    bit(8) objectTypeIndication;
+    bit(6) streamType;
+    bit(1) upStream;
+    const bit(1) reserved=1;
+    bit(24) bufferSizeDB;
+    bit(32) maxBitrate;
+    bit(32) avgBitrate;
+    DecoderSpecificInfo decSpecificInfo[0 .. 1];
+    profileLevelIndicationIndexDescriptor profileLevelIndicationIndexDescr [0..255];
+}
+*/
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct DecoderConfigDescriptor {
+    pub codec_type: CodecType,
+    pub object_type_indication: u8,
+    pub dec_specific_info: Option<DecoderSpecificInfo>,
+}
+
+impl ObjectDescriptor for DecoderConfigDescriptor {
+    fn read<B: ReadBytes>(reader: &mut B, len: u32) -> Result<Self> {
+        // AAC
+        const OBJECT_TYPE_ISO14496_3: u8 = 0x40;
+        const OBJECT_TYPE_ISO13818_7_MAIN: u8 = 0x66;
+        const OBJECT_TYPE_ISO13818_7_LC: u8 = 0x67;
+        // MP3
+        const OBJECT_TYPE_ISO13818_3: u8 = 0x69;
+        const OBJECT_TYPE_ISO11172_3: u8 = 0x6b;
+
+        let object_type_indication = reader.read_u8()?;
+
+        let (_stream_type, _upstream) = {
+            let val = reader.read_u8()?;
+
+            if val & 0x1 != 1 {
+                debug!("decoder config descriptor reserved bit is not 1");
+            }
+
+            ((val & 0xfc) >> 2, (val & 0x2) >> 1)
+        };
+
+        let _buffer_size = reader.read_be_u24()?;
+        let _max_bitrate = reader.read_be_u32()?;
+        let _avg_bitrate = reader.read_be_u32()?;
+
+        let mut dec_specific_config = None;
+
+        let mut scoped = ScopedStream::new(reader, u64::from(len) - 13);
+
+        // Multiple descriptors follow, but only the decoder specific info descriptor is useful.
+        while scoped.bytes_available() > MIN_DESCRIPTOR_SIZE {
+            let (desc, desc_len) = read_descriptor_header(&mut scoped)?;
+
+            match desc {
+                DECODER_SPECIFIC_DESCRIPTOR => {
+                    dec_specific_config = Some(DecoderSpecificInfo::read(&mut scoped, desc_len)?);
+                }
+                _ => {
+                    debug!("skipping {} object in decoder config descriptor", desc);
+                    scoped.ignore_bytes(u64::from(desc_len))?;
+                }
+            }
+        }
+
+        let codec_type = match object_type_indication {
+            OBJECT_TYPE_ISO14496_3 | OBJECT_TYPE_ISO13818_7_LC | OBJECT_TYPE_ISO13818_7_MAIN => {
+                CODEC_TYPE_AAC
+            }
+            OBJECT_TYPE_ISO13818_3 | OBJECT_TYPE_ISO11172_3 => CODEC_TYPE_MP3,
+            _ => {
+                debug!(
+                    "unknown object type indication {:#x} for decoder config descriptor",
+                    object_type_indication
+                );
+
+                CODEC_TYPE_NULL
+            }
+        };
+
+        // Consume remaining bytes.
+        scoped.ignore()?;
+
+        Ok(DecoderConfigDescriptor {
+            codec_type,
+            object_type_indication,
+            dec_specific_info: dec_specific_config,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct DecoderSpecificInfo {
+    pub extra_data: Box<[u8]>,
+}
+
+impl ObjectDescriptor for DecoderSpecificInfo {
+    fn read<B: ReadBytes>(reader: &mut B, len: u32) -> Result<Self> {
+        Ok(DecoderSpecificInfo { extra_data: reader.read_boxed_slice_exact(len as usize)? })
+    }
+}
+
+/*
+class SLConfigDescriptor extends BaseDescriptor : bit(8) tag=SLConfigDescrTag {
+    bit(8) predefined;
+    if (predefined==0) {
+        bit(1) useAccessUnitStartFlag;
+        bit(1) useAccessUnitEndFlag;
+        bit(1) useRandomAccessPointFlag;
+        bit(1) hasRandomAccessUnitsOnlyFlag;
+        bit(1) usePaddingFlag;
+        bit(1) useTimeStampsFlag;
+        bit(1) useIdleFlag;
+        bit(1) durationFlag;
+        bit(32) timeStampResolution;
+        bit(32) OCRResolution;
+        bit(8) timeStampLength; // must be  64
+        bit(8) OCRLength; // must be  64
+        bit(8) AU_Length; // must be  32
+        bit(8) instantBitrateLength;
+        bit(4) degradationPriorityLength;
+        bit(5) AU_seqNumLength; // must be  16
+        bit(5) packetSeqNumLength; // must be  16
+        bit(2) reserved=0b11;
+    }
+    if (durationFlag) {
+        bit(32) timeScale;
+        bit(16) accessUnitDuration;
+        bit(16) compositionUnitDuration;
+    }
+    if (!useTimeStampsFlag) {
+        bit(timeStampLength) startDecodingTimeStamp;
+        bit(timeStampLength) startCompositionTimeStamp;
+    }
+}
+
+timeStampLength == 32, for predefined == 0x1
+timeStampLength == 0,  for predefined == 0x2
+*/
+#[derive(Debug)]
+pub struct SLDescriptor;
+
+impl ObjectDescriptor for SLDescriptor {
+    fn read<B: ReadBytes>(reader: &mut B, len: u32) -> Result<Self> {
+        // const SLCONFIG_PREDEFINED_CUSTOM: u8 = 0x0;
+        const SLCONFIG_PREDEFINED_NULL: u8 = 0x1;  // older iTunes M4A
+        const SLCONFIG_PREDEFINED_MP4: u8 = 0x2;
+
+        let predefined = reader.read_u8()?;
+
+        match predefined {
+            SLCONFIG_PREDEFINED_MP4 => {
+                // Standard MP4: no extra fields. Nothing to read.
+            }
+            SLCONFIG_PREDEFINED_NULL => {
+                // Older iTunes files use predefined=0x1. The SL descriptor in
+                // this mode has no additional fields beyond the predefined byte,
+                // so we just ignore the remaining bytes.
+                if len > 1 {
+                    reader.ignore_bytes(u64::from(len - 1))?;
+                }
+            }
+            _ => {
+                return unsupported_error("isomp4: sl descriptor predefined not mp4 or null");
+            }
+        }
+
+        Ok(SLDescriptor {})
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/flac.rs

@@ -0,0 +1,77 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::codecs::{CodecParameters, VerificationCheck, CODEC_TYPE_FLAC};
+use symphonia_core::errors::{decode_error, unsupported_error, Result};
+use symphonia_core::io::{BufReader, ReadBytes};
+
+use symphonia_utils_xiph::flac::metadata::{MetadataBlockHeader, MetadataBlockType, StreamInfo};
+
+use crate::atoms::{Atom, AtomHeader};
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct FlacAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// FLAC stream info block.
+    stream_info: StreamInfo,
+    /// FLAC extra data.
+    extra_data: Box<[u8]>,
+}
+
+impl Atom for FlacAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (version, flags) = AtomHeader::read_extra(reader)?;
+
+        if version != 0 {
+            return unsupported_error("isomp4 (flac): unsupported flac version");
+        }
+
+        if flags != 0 {
+            return decode_error("isomp4 (flac): flags not zero");
+        }
+
+        // The first block must be the stream information block.
+        let block_header = MetadataBlockHeader::read(reader)?;
+
+        if block_header.block_type != MetadataBlockType::StreamInfo {
+            return decode_error("isomp4 (flac): first block is not stream info");
+        }
+
+        // Ensure the block length is correct for a stream information block before allocating a
+        // buffer for it.
+        if !StreamInfo::is_valid_size(u64::from(block_header.block_len)) {
+            return decode_error("isomp4 (flac): invalid stream info block length");
+        }
+
+        let extra_data = reader.read_boxed_slice_exact(block_header.block_len as usize)?;
+        let stream_info = StreamInfo::read(&mut BufReader::new(&extra_data))?;
+
+        Ok(FlacAtom { header, stream_info, extra_data })
+    }
+}
+
+impl FlacAtom {
+    pub fn fill_codec_params(&self, codec_params: &mut CodecParameters) {
+        codec_params
+            .for_codec(CODEC_TYPE_FLAC)
+            .with_sample_rate(self.stream_info.sample_rate)
+            .with_bits_per_sample(self.stream_info.bits_per_sample)
+            .with_channels(self.stream_info.channels)
+            .with_packet_data_integrity(true)
+            .with_extra_data(self.extra_data.clone());
+
+        if let Some(md5) = self.stream_info.md5 {
+            codec_params.with_verification_code(VerificationCheck::Md5(md5));
+        }
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/ftyp.rs

@@ -0,0 +1,54 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+use crate::fourcc::FourCc;
+
+/// File type atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct FtypAtom {
+    header: AtomHeader,
+    pub major: FourCc,
+    pub minor: [u8; 4],
+    pub compatible: Vec<FourCc>,
+}
+
+impl Atom for FtypAtom {
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        // The Ftyp atom must be have a data length that is known, and it must be a multiple of 4
+        // since it only stores FourCCs.
+        if header.data_len < 8 || header.data_len & 0x3 != 0 {
+            return decode_error("isomp4: invalid ftyp data length");
+        }
+
+        // Major
+        let major = FourCc::new(reader.read_quad_bytes()?);
+
+        // Minor
+        let minor = reader.read_quad_bytes()?;
+
+        // The remainder of the Ftyp atom contains the FourCCs of compatible brands.
+        let n_brands = (header.data_len - 8) / 4;
+
+        let mut compatible = Vec::new();
+
+        for _ in 0..n_brands {
+            let brand = reader.read_quad_bytes()?;
+            compatible.push(FourCc::new(brand));
+        }
+
+        Ok(FtypAtom { header, major, minor, compatible })
+    }
+
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/hdlr.rs

@@ -0,0 +1,80 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::{
+    atoms::{Atom, AtomHeader},
+    fourcc::FourCc,
+};
+
+use log::warn;
+
+/// Handler type.
+#[derive(Debug, PartialEq, Eq)]
+pub enum HandlerType {
+    /// Video handler.
+    Video,
+    /// Audio handler.
+    Sound,
+    /// Subtitle handler.
+    Subtitle,
+    /// Metadata handler.
+    Metadata,
+    /// Text handler.
+    Text,
+    /// Unknown handler type.
+    Other([u8; 4]),
+}
+
+/// Handler atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct HdlrAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Handler type.
+    pub handler_type: HandlerType,
+    /// Human-readable handler name.
+    pub name: String,
+}
+
+impl Atom for HdlrAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        // Always 0 for MP4, but for Quicktime this contains the component type.
+        let _ = reader.read_quad_bytes()?;
+
+        let handler_type = match &reader.read_quad_bytes()? {
+            b"vide" => HandlerType::Video,
+            b"soun" => HandlerType::Sound,
+            b"meta" => HandlerType::Metadata,
+            b"subt" => HandlerType::Subtitle,
+            b"text" => HandlerType::Text,
+            &hdlr => {
+                warn!("unknown handler type {:?}", FourCc::new(hdlr));
+                HandlerType::Other(hdlr)
+            }
+        };
+
+        // These bytes are reserved for MP4, but for QuickTime they contain the component
+        // manufacturer, flags, and flags mask.
+        reader.ignore_bytes(4 * 3)?;
+
+        // Human readable UTF-8 string of the track type.
+        let buf = reader.read_boxed_slice_exact((header.data_len - 24) as usize)?;
+        let name = String::from_utf8_lossy(&buf).to_string();
+
+        Ok(HdlrAtom { header, handler_type, name })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/ilst.rs

@@ -0,0 +1,767 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::{BufReader, ReadBytes};
+use symphonia_core::meta::{
+    MetadataBuilder, MetadataRevision, StandardTagKey, StandardVisualKey, Tag,
+};
+use symphonia_core::meta::{Value, Visual};
+use symphonia_core::util::bits;
+use symphonia_metadata::{id3v1, itunes};
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType};
+
+use encoding_rs::{SHIFT_JIS, UTF_16BE};
+use log::warn;
+
+/// Data type enumeration for metadata value atoms as defined in the QuickTime File Format standard.
+#[allow(dead_code)]
+#[derive(Debug, Copy, Clone)]
+pub enum DataType {
+    AffineTransformF64,
+    Bmp,
+    DimensionsF32,
+    Float32,
+    Float64,
+    Jpeg,
+    /// The data type is implicit to the atom.
+    NoType,
+    Png,
+    PointF32,
+    QuickTimeMetadata,
+    RectF32,
+    ShiftJis,
+    SignedInt16,
+    SignedInt32,
+    SignedInt64,
+    SignedInt8,
+    SignedIntVariable,
+    UnsignedInt16,
+    UnsignedInt32,
+    UnsignedInt64,
+    UnsignedInt8,
+    UnsignedIntVariable,
+    Utf16,
+    Utf16Sort,
+    Utf8,
+    Utf8Sort,
+    Unknown(u32),
+}
+
+impl From<u32> for DataType {
+    fn from(value: u32) -> Self {
+        match value {
+            0 => DataType::NoType,
+            1 => DataType::Utf8,
+            2 => DataType::Utf16,
+            3 => DataType::ShiftJis,
+            4 => DataType::Utf8Sort,
+            5 => DataType::Utf16Sort,
+            13 => DataType::Jpeg,
+            14 => DataType::Png,
+            21 => DataType::SignedIntVariable,
+            22 => DataType::UnsignedIntVariable,
+            23 => DataType::Float32,
+            24 => DataType::Float64,
+            27 => DataType::Bmp,
+            28 => DataType::QuickTimeMetadata,
+            65 => DataType::SignedInt8,
+            66 => DataType::SignedInt16,
+            67 => DataType::SignedInt32,
+            70 => DataType::PointF32,
+            71 => DataType::DimensionsF32,
+            72 => DataType::RectF32,
+            74 => DataType::SignedInt64,
+            75 => DataType::UnsignedInt8,
+            76 => DataType::UnsignedInt16,
+            77 => DataType::UnsignedInt32,
+            78 => DataType::UnsignedInt64,
+            79 => DataType::AffineTransformF64,
+            _ => DataType::Unknown(value),
+        }
+    }
+}
+
+fn parse_no_type(data: &[u8]) -> Option<Value> {
+    // Latin1, potentially null-terminated.
+    let end = data.iter().position(|&c| c == b'\0').unwrap_or(data.len());
+    let text = String::from_utf8_lossy(&data[..end]);
+    Some(Value::from(text))
+}
+
+fn parse_utf8(data: &[u8]) -> Option<Value> {
+    // UTF8, no null-terminator or count.
+    let text = String::from_utf8_lossy(data);
+    Some(Value::from(text))
+}
+
+fn parse_utf16(data: &[u8]) -> Option<Value> {
+    // UTF16 BE
+    let text = UTF_16BE.decode(data).0;
+    Some(Value::from(text))
+}
+
+fn parse_shift_jis(data: &[u8]) -> Option<Value> {
+    // Shift-JIS
+    let text = SHIFT_JIS.decode(data).0;
+    Some(Value::from(text))
+}
+
+fn parse_signed_int8(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        1 => {
+            let s = bits::sign_extend_leq8_to_i8(data[0], 8);
+            Some(Value::from(s))
+        }
+        _ => None,
+    }
+}
+
+fn parse_signed_int16(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        2 => {
+            let u = BufReader::new(data).read_be_u16().ok()?;
+            let s = bits::sign_extend_leq16_to_i16(u, 16);
+            Some(Value::from(s))
+        }
+        _ => None,
+    }
+}
+
+fn parse_signed_int32(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        4 => {
+            let u = BufReader::new(data).read_be_u32().ok()?;
+            let s = bits::sign_extend_leq32_to_i32(u, 32);
+            Some(Value::from(s))
+        }
+        _ => None,
+    }
+}
+
+fn parse_signed_int64(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        8 => {
+            let u = BufReader::new(data).read_be_u64().ok()?;
+            let s = bits::sign_extend_leq64_to_i64(u, 64);
+            Some(Value::from(s))
+        }
+        _ => None,
+    }
+}
+
+fn parse_var_signed_int(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        1 => parse_signed_int8(data),
+        2 => parse_signed_int16(data),
+        4 => parse_signed_int32(data),
+        _ => None,
+    }
+}
+
+fn parse_unsigned_int8(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        1 => Some(Value::from(data[0])),
+        _ => None,
+    }
+}
+
+fn parse_unsigned_int16(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        2 => {
+            let u = BufReader::new(data).read_be_u16().ok()?;
+            Some(Value::from(u))
+        }
+        _ => None,
+    }
+}
+
+fn parse_unsigned_int32(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        4 => {
+            let u = BufReader::new(data).read_be_u32().ok()?;
+            Some(Value::from(u))
+        }
+        _ => None,
+    }
+}
+
+fn parse_unsigned_int64(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        8 => {
+            let u = BufReader::new(data).read_be_u64().ok()?;
+            Some(Value::from(u))
+        }
+        _ => None,
+    }
+}
+
+fn parse_var_unsigned_int(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        1 => parse_unsigned_int8(data),
+        2 => parse_unsigned_int16(data),
+        4 => parse_unsigned_int32(data),
+        _ => None,
+    }
+}
+
+fn parse_float32(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        4 => {
+            let f = BufReader::new(data).read_be_f32().ok()?;
+            Some(Value::Float(f64::from(f)))
+        }
+        _ => None,
+    }
+}
+
+fn parse_float64(data: &[u8]) -> Option<Value> {
+    match data.len() {
+        8 => {
+            let f = BufReader::new(data).read_be_f64().ok()?;
+            Some(Value::Float(f))
+        }
+        _ => None,
+    }
+}
+
+fn parse_tag_value(data_type: DataType, data: &[u8]) -> Option<Value> {
+    match data_type {
+        DataType::NoType => parse_no_type(data),
+        DataType::Utf8 | DataType::Utf8Sort => parse_utf8(data),
+        DataType::Utf16 | DataType::Utf16Sort => parse_utf16(data),
+        DataType::ShiftJis => parse_shift_jis(data),
+        DataType::UnsignedInt8 => parse_unsigned_int8(data),
+        DataType::UnsignedInt16 => parse_unsigned_int16(data),
+        DataType::UnsignedInt32 => parse_unsigned_int32(data),
+        DataType::UnsignedInt64 => parse_unsigned_int64(data),
+        DataType::UnsignedIntVariable => parse_var_unsigned_int(data),
+        DataType::SignedInt8 => parse_signed_int8(data),
+        DataType::SignedInt16 => parse_signed_int16(data),
+        DataType::SignedInt32 => parse_signed_int32(data),
+        DataType::SignedInt64 => parse_signed_int64(data),
+        DataType::SignedIntVariable => parse_var_signed_int(data),
+        DataType::Float32 => parse_float32(data),
+        DataType::Float64 => parse_float64(data),
+        _ => None,
+    }
+}
+
+/// Reads and parses a `MetaTagAtom` from the provided iterator and adds it to the `MetadataBuilder`
+/// if there are no errors.
+fn add_generic_tag<B: ReadBytes>(
+    iter: &mut AtomIterator<B>,
+    builder: &mut MetadataBuilder,
+    std_key: Option<StandardTagKey>,
+) -> Result<()> {
+    let tag = iter.read_atom::<MetaTagAtom>()?;
+
+    for value_atom in tag.values.iter() {
+        // Parse the value atom data into a string, if possible.
+        if let Some(value) = parse_tag_value(value_atom.data_type, &value_atom.data) {
+            builder.add_tag(Tag::new(std_key, "", value));
+        }
+        else {
+            warn!("unsupported data type {:?} for {:?} tag", value_atom.data_type, std_key);
+        }
+    }
+
+    Ok(())
+}
+
+fn add_var_unsigned_int_tag<B: ReadBytes>(
+    iter: &mut AtomIterator<B>,
+    builder: &mut MetadataBuilder,
+    std_key: StandardTagKey,
+) -> Result<()> {
+    let tag = iter.read_atom::<MetaTagAtom>()?;
+
+    if let Some(value_atom) = tag.values.first() {
+        if let Some(value) = parse_var_unsigned_int(&value_atom.data) {
+            builder.add_tag(Tag::new(Some(std_key), "", value));
+        }
+        else {
+            warn!("got unexpected data for {:?} tag", std_key);
+        }
+    }
+
+    Ok(())
+}
+
+fn add_var_signed_int_tag<B: ReadBytes>(
+    iter: &mut AtomIterator<B>,
+    builder: &mut MetadataBuilder,
+    std_key: StandardTagKey,
+) -> Result<()> {
+    let tag = iter.read_atom::<MetaTagAtom>()?;
+
+    if let Some(value_atom) = tag.values.first() {
+        if let Some(value) = parse_var_signed_int(&value_atom.data) {
+            builder.add_tag(Tag::new(Some(std_key), "", value));
+        }
+        else {
+            warn!("got unexpected data for {:?} tag", std_key);
+        }
+    }
+
+    Ok(())
+}
+
+fn add_boolean_tag<B: ReadBytes>(
+    iter: &mut AtomIterator<B>,
+    builder: &mut MetadataBuilder,
+    std_key: StandardTagKey,
+) -> Result<()> {
+    let tag = iter.read_atom::<MetaTagAtom>()?;
+
+    // There should only be 1 value.
+    if let Some(value) = tag.values.first() {
+        // Boolean tags are just "flags", only add a tag if the boolean is true (1).
+        if let Some(bool_value) = value.data.first() {
+            if *bool_value == 1 {
+                builder.add_tag(Tag::new(Some(std_key), "", Value::Flag));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn add_m_of_n_tag<B: ReadBytes>(
+    iter: &mut AtomIterator<B>,
+    builder: &mut MetadataBuilder,
+    m_key: StandardTagKey,
+    n_key: StandardTagKey,
+) -> Result<()> {
+    let tag = iter.read_atom::<MetaTagAtom>()?;
+
+    // There should only be 1 value.
+    if let Some(value) = tag.values.first() {
+        // The trkn and disk atoms contains an 8 byte value buffer, where the 4th and 6th bytes
+        // indicate the track/disk number and total number of tracks/disks, respectively. Odd.
+        if value.data.len() == 8 {
+            let m = value.data[3];
+            let n = value.data[5];
+
+            builder.add_tag(Tag::new(Some(m_key), "", Value::from(m)));
+            builder.add_tag(Tag::new(Some(n_key), "", Value::from(n)));
+        }
+    }
+
+    Ok(())
+}
+
+fn add_visual_tag<B: ReadBytes>(
+    iter: &mut AtomIterator<B>,
+    builder: &mut MetadataBuilder,
+) -> Result<()> {
+    let tag = iter.read_atom::<MetaTagAtom>()?;
+
+    // There could be more than one attached image.
+    for value in tag.values {
+        let media_type = match value.data_type {
+            DataType::Bmp => "image/bmp",
+            DataType::Jpeg => "image/jpeg",
+            DataType::Png => "image/png",
+            _ => "",
+        };
+
+        builder.add_visual(Visual {
+            media_type: media_type.into(),
+            dimensions: None,
+            bits_per_pixel: None,
+            color_mode: None,
+            usage: Some(StandardVisualKey::FrontCover),
+            tags: Default::default(),
+            data: value.data,
+        });
+    }
+
+    Ok(())
+}
+
+fn add_advisory_tag<B: ReadBytes>(
+    _iter: &mut AtomIterator<B>,
+    _builder: &mut MetadataBuilder,
+) -> Result<()> {
+    Ok(())
+}
+
+fn add_media_type_tag<B: ReadBytes>(
+    iter: &mut AtomIterator<B>,
+    builder: &mut MetadataBuilder,
+) -> Result<()> {
+    let tag = iter.read_atom::<MetaTagAtom>()?;
+
+    // There should only be 1 value.
+    if let Some(value) = tag.values.first() {
+        if let Some(media_type_value) = value.data.first() {
+            let media_type = match media_type_value {
+                0 => "Movie",
+                1 => "Normal",
+                2 => "Audio Book",
+                5 => "Whacked Bookmark",
+                6 => "Music Video",
+                9 => "Short Film",
+                10 => "TV Show",
+                11 => "Booklet",
+                _ => "Unknown",
+            };
+
+            builder.add_tag(Tag::new(
+                Some(StandardTagKey::MediaFormat),
+                "",
+                Value::from(media_type),
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+fn add_id3v1_genre_tag<B: ReadBytes>(
+    iter: &mut AtomIterator<B>,
+    builder: &mut MetadataBuilder,
+) -> Result<()> {
+    let tag = iter.read_atom::<MetaTagAtom>()?;
+
+    // There should only be 1 value.
+    if let Some(value) = tag.values.first() {
+        // The ID3v1 genre is stored as a unsigned 16-bit big-endian integer.
+        let index = BufReader::new(&value.data).read_be_u16()?;
+
+        // The stored index uses 1-based indexing, but the ID3v1 genre list is 0-based.
+        if index > 0 {
+            if let Some(genre) = id3v1::util::genre_name((index - 1) as u8) {
+                builder.add_tag(Tag::new(Some(StandardTagKey::Genre), "", Value::from(*genre)));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn add_freeform_tag<B: ReadBytes>(
+    iter: &mut AtomIterator<B>,
+    builder: &mut MetadataBuilder,
+) -> Result<()> {
+    let tag = iter.read_atom::<MetaTagAtom>()?;
+
+    // A user-defined tag should only have 1 value.
+    for value_atom in tag.values.iter() {
+        // Parse the value atom data into a string, if possible.
+        if let Some(value) = parse_tag_value(value_atom.data_type, &value_atom.data) {
+            // Gets the fully qualified tag name.
+            let full_name = tag.full_name();
+
+            // Try to map iTunes freeform tags to standard tag keys.
+            let std_key = itunes::std_key_from_tag(&full_name);
+
+            builder.add_tag(Tag::new(std_key, &full_name, value));
+        }
+        else {
+            warn!("unsupported data type {:?} for free-form tag", value_atom.data_type);
+        }
+    }
+
+    Ok(())
+}
+
+/// Metadata tag data atom.
+#[allow(dead_code)]
+pub struct MetaTagDataAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Tag data.
+    pub data: Box<[u8]>,
+    /// The data type contained in buf.
+    pub data_type: DataType,
+}
+
+impl Atom for MetaTagDataAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (version, flags) = AtomHeader::read_extra(reader)?;
+
+        // For the mov brand, this a data type indicator and must always be 0 (well-known type). It
+        // specifies the table in which the next 24-bit integer specifying the actual data type
+        // indexes. For iso/mp4, this is a version, and there is only one version, 0. Therefore,
+        // flags are interpreted as the actual data type index.
+        if version != 0 {
+            return decode_error("isomp4: invalid data atom version");
+        }
+
+        let data_type = DataType::from(flags);
+
+        // For the mov brand, the next four bytes are country and languages code. However, for
+        // iso/mp4 these codes should be ignored.
+        let _country = reader.read_be_u16()?;
+        let _language = reader.read_be_u16()?;
+
+        // The data payload is the remainder of the atom.
+        // TODO: Apply a limit.
+        let data = reader
+            .read_boxed_slice_exact((header.data_len - AtomHeader::EXTRA_DATA_SIZE - 4) as usize)?;
+
+        Ok(MetaTagDataAtom { header, data, data_type })
+    }
+}
+
+/// Metadata tag name and mean atom.
+#[allow(dead_code)]
+pub struct MetaTagNamespaceAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// For 'mean' atoms, this is the key namespace. For 'name' atom, this is the key name.
+    pub value: String,
+}
+
+impl Atom for MetaTagNamespaceAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        let buf = reader
+            .read_boxed_slice_exact((header.data_len - AtomHeader::EXTRA_DATA_SIZE) as usize)?;
+
+        // Do a lossy conversion because metadata should not prevent the demuxer from working.
+        let value = String::from_utf8_lossy(&buf).to_string();
+
+        Ok(MetaTagNamespaceAtom { header, value })
+    }
+}
+
+/// A generic metadata tag atom.
+#[allow(dead_code)]
+pub struct MetaTagAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Tag value(s).
+    pub values: Vec<MetaTagDataAtom>,
+    /// Optional, tag key namespace.
+    pub mean: Option<MetaTagNamespaceAtom>,
+    /// Optional, tag key name.
+    pub name: Option<MetaTagNamespaceAtom>,
+}
+
+impl MetaTagAtom {
+    pub fn full_name(&self) -> String {
+        let mut full_name = String::new();
+
+        if self.mean.is_some() || self.name.is_some() {
+            // full_name.push_str("----:");
+
+            if let Some(mean) = &self.mean {
+                full_name.push_str(&mean.value);
+            }
+
+            full_name.push(':');
+
+            if let Some(name) = &self.name {
+                full_name.push_str(&name.value);
+            }
+        }
+
+        full_name
+    }
+}
+
+impl Atom for MetaTagAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut mean = None;
+        let mut name = None;
+        let mut values = Vec::new();
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::MetaTagData => {
+                    values.push(iter.read_atom::<MetaTagDataAtom>()?);
+                }
+                AtomType::MetaTagName => {
+                    name = Some(iter.read_atom::<MetaTagNamespaceAtom>()?);
+                }
+                AtomType::MetaTagMeaning => {
+                    mean = Some(iter.read_atom::<MetaTagNamespaceAtom>()?);
+                }
+                _ => (),
+            }
+        }
+
+        Ok(MetaTagAtom { header, values, mean, name })
+    }
+}
+
+/// User data atom.
+#[allow(dead_code)]
+pub struct IlstAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Metadata revision.
+    pub metadata: MetadataRevision,
+}
+
+impl Atom for IlstAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut mb = MetadataBuilder::new();
+
+        while let Some(header) = iter.next()? {
+            // Ignore standard atoms, check if other is a metadata atom.
+            match &header.atype {
+                AtomType::AdvisoryTag => add_advisory_tag(&mut iter, &mut mb)?,
+                AtomType::AlbumArtistTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::AlbumArtist))?
+                }
+                AtomType::AlbumTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Album))?
+                }
+                AtomType::ArtistLowerTag => (),
+                AtomType::ArtistTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Artist))?
+                }
+                AtomType::CategoryTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::PodcastCategory))?
+                }
+                AtomType::CommentTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Comment))?
+                }
+                AtomType::CompilationTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Compilation))?
+                }
+                AtomType::ComposerTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Composer))?
+                }
+                AtomType::CopyrightTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Copyright))?
+                }
+                AtomType::CoverTag => add_visual_tag(&mut iter, &mut mb)?,
+                AtomType::CustomGenreTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Genre))?
+                }
+                AtomType::DateTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Date))?
+                }
+                AtomType::DescriptionTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Description))?
+                }
+                AtomType::DiskNumberTag => add_m_of_n_tag(
+                    &mut iter,
+                    &mut mb,
+                    StandardTagKey::DiscNumber,
+                    StandardTagKey::DiscTotal,
+                )?,
+                AtomType::EncodedByTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::EncodedBy))?
+                }
+                AtomType::EncoderTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Encoder))?
+                }
+                AtomType::GaplessPlaybackTag => {
+                    // TODO: Need standard tag key for gapless playback.
+                    // add_boolean_tag(&mut iter, &mut mb, )?
+                }
+                AtomType::GenreTag => add_id3v1_genre_tag(&mut iter, &mut mb)?,
+                AtomType::GroupingTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::ContentGroup))?
+                }
+                AtomType::HdVideoTag => (),
+                AtomType::IdentPodcastTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::IdentPodcast))?
+                }
+                AtomType::KeywordTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::PodcastKeywords))?
+                }
+                AtomType::LongDescriptionTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Description))?
+                }
+                AtomType::LyricsTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Lyrics))?
+                }
+                AtomType::MediaTypeTag => add_media_type_tag(&mut iter, &mut mb)?,
+                AtomType::OwnerTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Owner))?
+                }
+                AtomType::PodcastTag => {
+                    add_boolean_tag(&mut iter, &mut mb, StandardTagKey::Podcast)?
+                }
+                AtomType::PurchaseDateTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::PurchaseDate))?
+                }
+                AtomType::RatingTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::Rating))?
+                }
+                AtomType::SortAlbumArtistTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::SortAlbumArtist))?
+                }
+                AtomType::SortAlbumTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::SortAlbum))?
+                }
+                AtomType::SortArtistTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::SortArtist))?
+                }
+                AtomType::SortComposerTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::SortComposer))?
+                }
+                AtomType::SortNameTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::SortTrackTitle))?
+                }
+                AtomType::TempoTag => {
+                    add_var_signed_int_tag(&mut iter, &mut mb, StandardTagKey::Bpm)?
+                }
+                AtomType::TrackNumberTag => add_m_of_n_tag(
+                    &mut iter,
+                    &mut mb,
+                    StandardTagKey::TrackNumber,
+                    StandardTagKey::TrackTotal,
+                )?,
+                AtomType::TrackTitleTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::TrackTitle))?
+                }
+                AtomType::TvEpisodeNameTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::TvEpisodeTitle))?
+                }
+                AtomType::TvEpisodeNumberTag => {
+                    add_var_unsigned_int_tag(&mut iter, &mut mb, StandardTagKey::TvEpisode)?
+                }
+                AtomType::TvNetworkNameTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::TvNetwork))?
+                }
+                AtomType::TvSeasonNumberTag => {
+                    add_var_unsigned_int_tag(&mut iter, &mut mb, StandardTagKey::TvSeason)?
+                }
+                AtomType::TvShowNameTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::TvShowTitle))?
+                }
+                AtomType::UrlPodcastTag => {
+                    add_generic_tag(&mut iter, &mut mb, Some(StandardTagKey::UrlPodcast))?
+                }
+                AtomType::FreeFormTag => add_freeform_tag(&mut iter, &mut mb)?,
+                _ => (),
+            }
+        }
+
+        Ok(IlstAtom { header, metadata: mb.metadata() })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/mdhd.rs

@@ -0,0 +1,93 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+fn parse_language(code: u16) -> String {
+    // An ISO language code outside of these bounds is not valid.
+    if code < 0x400 || code > 0x7fff {
+        String::new()
+    }
+    else {
+        let chars = [
+            ((code >> 10) & 0x1f) as u8 + 0x60,
+            ((code >> 5) & 0x1f) as u8 + 0x60,
+            ((code >> 0) & 0x1f) as u8 + 0x60,
+        ];
+
+        String::from_utf8_lossy(&chars).to_string()
+    }
+}
+
+/// Media header atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct MdhdAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Creation time.
+    pub ctime: u64,
+    /// Modification time.
+    pub mtime: u64,
+    /// Timescale.
+    pub timescale: u32,
+    /// Duration of the media in timescale units.
+    pub duration: u64,
+    /// Language.
+    pub language: String,
+}
+
+impl Atom for MdhdAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (version, _) = AtomHeader::read_extra(reader)?;
+
+        let mut mdhd = MdhdAtom {
+            header,
+            ctime: 0,
+            mtime: 0,
+            timescale: 0,
+            duration: 0,
+            language: String::new(),
+        };
+
+        match version {
+            0 => {
+                mdhd.ctime = u64::from(reader.read_be_u32()?);
+                mdhd.mtime = u64::from(reader.read_be_u32()?);
+                mdhd.timescale = reader.read_be_u32()?;
+                // 0xffff_ffff is a special case.
+                mdhd.duration = match reader.read_be_u32()? {
+                    u32::MAX => u64::MAX,
+                    duration => u64::from(duration),
+                };
+            }
+            1 => {
+                mdhd.ctime = reader.read_be_u64()?;
+                mdhd.mtime = reader.read_be_u64()?;
+                mdhd.timescale = reader.read_be_u32()?;
+                mdhd.duration = reader.read_be_u64()?;
+            }
+            _ => {
+                return decode_error("isomp4: invalid mdhd version");
+            }
+        }
+
+        mdhd.language = parse_language(reader.read_be_u16()?);
+
+        // Quality
+        let _ = reader.read_be_u16()?;
+
+        Ok(mdhd)
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/mdia.rs

@@ -0,0 +1,63 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType, HdlrAtom, MdhdAtom, MinfAtom};
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct MdiaAtom {
+    header: AtomHeader,
+    pub mdhd: MdhdAtom,
+    pub hdlr: HdlrAtom,
+    pub minf: MinfAtom,
+}
+
+impl Atom for MdiaAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut mdhd = None;
+        let mut hdlr = None;
+        let mut minf = None;
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::MediaHeader => {
+                    mdhd = Some(iter.read_atom::<MdhdAtom>()?);
+                }
+                AtomType::Handler => {
+                    hdlr = Some(iter.read_atom::<HdlrAtom>()?);
+                }
+                AtomType::MediaInfo => {
+                    minf = Some(iter.read_atom::<MinfAtom>()?);
+                }
+                _ => (),
+            }
+        }
+
+        if mdhd.is_none() {
+            return decode_error("isomp4: missing mdhd atom");
+        }
+
+        if hdlr.is_none() {
+            return decode_error("isomp4: missing hdlr atom");
+        }
+
+        if minf.is_none() {
+            return decode_error("isomp4: missing minf atom");
+        }
+
+        Ok(MdiaAtom { header, mdhd: mdhd.unwrap(), hdlr: hdlr.unwrap(), minf: minf.unwrap() })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/mehd.rs

@@ -0,0 +1,41 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+/// Movie extends header atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct MehdAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Fragment duration.
+    pub fragment_duration: u64,
+}
+
+impl Atom for MehdAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (version, _) = AtomHeader::read_extra(reader)?;
+
+        let fragment_duration = match version {
+            0 => u64::from(reader.read_be_u32()?),
+            1 => reader.read_be_u64()?,
+            _ => {
+                return decode_error("isomp4: invalid mehd version");
+            }
+        };
+
+        Ok(MehdAtom { header, fragment_duration })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/meta.rs

@@ -0,0 +1,66 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use std::fmt::Debug;
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+use symphonia_core::meta::MetadataRevision;
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType, IlstAtom};
+
+/// User data atom.
+#[allow(dead_code)]
+pub struct MetaAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Metadata revision.
+    pub metadata: Option<MetadataRevision>,
+}
+
+impl Debug for MetaAtom {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "(redacted)")
+    }
+}
+
+impl MetaAtom {
+    /// If metadata was read, consumes the metadata and returns it.
+    pub fn take_metadata(&mut self) -> Option<MetadataRevision> {
+        self.metadata.take()
+    }
+}
+
+impl Atom for MetaAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    #[allow(clippy::single_match)]
+    fn read<B: ReadBytes>(reader: &mut B, mut header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        // AtomIterator doesn't know the extra data was read already, so the extra data size must be
+        // subtrated from the atom's data length.
+        header.data_len -= AtomHeader::EXTRA_DATA_SIZE;
+
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut metadata = None;
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::MetaList => {
+                    metadata = Some(iter.read_atom::<IlstAtom>()?.metadata);
+                }
+                _ => (),
+            }
+        }
+
+        Ok(MetaAtom { header, metadata })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/mfhd.rs

@@ -0,0 +1,35 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+/// Movie fragment header atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct MfhdAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Sequence number associated with fragment.
+    pub sequence_number: u32,
+}
+
+impl Atom for MfhdAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        let sequence_number = reader.read_be_u32()?;
+
+        Ok(MfhdAtom { header, sequence_number })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/minf.rs

@@ -0,0 +1,54 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType, SmhdAtom, StblAtom};
+
+/// Media information atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct MinfAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Sound media header atom.
+    pub smhd: Option<SmhdAtom>,
+    /// Sample table atom.
+    pub stbl: StblAtom,
+}
+
+impl Atom for MinfAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut smhd = None;
+        let mut stbl = None;
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::SoundMediaHeader => {
+                    smhd = Some(iter.read_atom::<SmhdAtom>()?);
+                }
+                AtomType::SampleTable => {
+                    stbl = Some(iter.read_atom::<StblAtom>()?);
+                }
+                _ => (),
+            }
+        }
+
+        if stbl.is_none() {
+            return decode_error("isomp4: missing stbl atom");
+        }
+
+        Ok(MinfAtom { header, smhd, stbl: stbl.unwrap() })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/mod.rs

@@ -0,0 +1,477 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+pub(crate) mod alac;
+pub(crate) mod co64;
+pub(crate) mod ctts;
+pub(crate) mod edts;
+pub(crate) mod elst;
+pub(crate) mod esds;
+pub(crate) mod flac;
+pub(crate) mod ftyp;
+pub(crate) mod hdlr;
+pub(crate) mod ilst;
+pub(crate) mod mdhd;
+pub(crate) mod mdia;
+pub(crate) mod mehd;
+pub(crate) mod meta;
+pub(crate) mod mfhd;
+pub(crate) mod minf;
+pub(crate) mod moof;
+pub(crate) mod moov;
+pub(crate) mod mvex;
+pub(crate) mod mvhd;
+pub(crate) mod opus;
+pub(crate) mod sidx;
+pub(crate) mod smhd;
+pub(crate) mod stbl;
+pub(crate) mod stco;
+pub(crate) mod stsc;
+pub(crate) mod stsd;
+pub(crate) mod stss;
+pub(crate) mod stsz;
+pub(crate) mod stts;
+pub(crate) mod tfhd;
+pub(crate) mod tkhd;
+pub(crate) mod traf;
+pub(crate) mod trak;
+pub(crate) mod trex;
+pub(crate) mod trun;
+pub(crate) mod udta;
+pub(crate) mod wave;
+
+pub use self::meta::MetaAtom;
+pub use alac::AlacAtom;
+pub use co64::Co64Atom;
+#[allow(unused_imports)]
+pub use ctts::CttsAtom;
+pub use edts::EdtsAtom;
+pub use elst::ElstAtom;
+pub use esds::EsdsAtom;
+pub use flac::FlacAtom;
+pub use ftyp::FtypAtom;
+pub use hdlr::HdlrAtom;
+pub use ilst::IlstAtom;
+pub use mdhd::MdhdAtom;
+pub use mdia::MdiaAtom;
+pub use mehd::MehdAtom;
+pub use mfhd::MfhdAtom;
+pub use minf::MinfAtom;
+pub use moof::MoofAtom;
+pub use moov::MoovAtom;
+pub use mvex::MvexAtom;
+pub use mvhd::MvhdAtom;
+pub use opus::OpusAtom;
+pub use sidx::SidxAtom;
+pub use smhd::SmhdAtom;
+pub use stbl::StblAtom;
+pub use stco::StcoAtom;
+pub use stsc::StscAtom;
+pub use stsd::StsdAtom;
+#[allow(unused_imports)]
+pub use stss::StssAtom;
+pub use stsz::StszAtom;
+pub use stts::SttsAtom;
+pub use tfhd::TfhdAtom;
+pub use tkhd::TkhdAtom;
+pub use traf::TrafAtom;
+pub use trak::TrakAtom;
+pub use trex::TrexAtom;
+pub use trun::TrunAtom;
+pub use udta::UdtaAtom;
+pub use wave::WaveAtom;
+
+/// Atom types.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum AtomType {
+    Ac3,
+    AdvisoryTag,
+    Alac,
+    ALaw,
+    AlbumArtistTag,
+    AlbumTag,
+    ArtistLowerTag,
+    ArtistTag,
+    CategoryTag,
+    ChunkOffset,
+    ChunkOffset64,
+    CommentTag,
+    CompilationTag,
+    ComposerTag,
+    CompositionTimeToSample,
+    CopyrightTag,
+    CoverTag,
+    CustomGenreTag,
+    DateTag,
+    DescriptionTag,
+    DiskNumberTag,
+    Edit,
+    EditList,
+    EncodedByTag,
+    EncoderTag,
+    Esds,
+    F32SampleEntry,
+    F64SampleEntry,
+    FileType,
+    Flac,
+    FlacDsConfig,
+    Free,
+    FreeFormTag,
+    GaplessPlaybackTag,
+    GenreTag,
+    GroupingTag,
+    Handler,
+    HdVideoTag,
+    IdentPodcastTag,
+    KeywordTag,
+    LongDescriptionTag,
+    Lpcm,
+    LyricsTag,
+    Media,
+    MediaData,
+    MediaHeader,
+    MediaInfo,
+    MediaTypeTag,
+    Meta,
+    MetaList,
+    MetaTagData,
+    MetaTagMeaning,
+    MetaTagName,
+    Movie,
+    MovieExtends,
+    MovieExtendsHeader,
+    MovieFragment,
+    MovieFragmentHeader,
+    MovieHeader,
+    Mp3,
+    Mp4a,
+    MuLaw,
+    Opus,
+    OpusDsConfig,
+    OwnerTag,
+    PodcastTag,
+    PurchaseDateTag,
+    QtWave,
+    RatingTag,
+    S16BeSampleEntry,
+    S16LeSampleEntry,
+    S24SampleEntry,
+    S32SampleEntry,
+    SampleDescription,
+    SampleSize,
+    SampleTable,
+    SampleToChunk,
+    SegmentIndex,
+    Skip,
+    SortAlbumArtistTag,
+    SortAlbumTag,
+    SortArtistTag,
+    SortComposerTag,
+    SortNameTag,
+    SoundMediaHeader,
+    SyncSample,
+    TempoTag,
+    TimeToSample,
+    Track,
+    TrackExtends,
+    TrackFragment,
+    TrackFragmentHeader,
+    TrackFragmentRun,
+    TrackHeader,
+    TrackNumberTag,
+    TrackTitleTag,
+    TvEpisodeNameTag,
+    TvEpisodeNumberTag,
+    TvNetworkNameTag,
+    TvSeasonNumberTag,
+    TvShowNameTag,
+    U8SampleEntry,
+    UrlPodcastTag,
+    UserData,
+    Other([u8; 4]),
+}
+
+impl From<[u8; 4]> for AtomType {
+    fn from(val: [u8; 4]) -> Self {
+        match &val {
+            b".mp3" => AtomType::Mp3,
+            b"ac-3" => AtomType::Ac3,
+            b"alac" => AtomType::Alac,
+            b"alaw" => AtomType::ALaw,
+            b"co64" => AtomType::ChunkOffset64,
+            b"ctts" => AtomType::CompositionTimeToSample,
+            b"data" => AtomType::MetaTagData,
+            b"dfLa" => AtomType::FlacDsConfig,
+            b"dOps" => AtomType::OpusDsConfig,
+            b"edts" => AtomType::Edit,
+            b"elst" => AtomType::EditList,
+            b"esds" => AtomType::Esds,
+            b"fl32" => AtomType::F32SampleEntry,
+            b"fl64" => AtomType::F64SampleEntry,
+            b"fLaC" => AtomType::Flac,
+            b"free" => AtomType::Free,
+            b"ftyp" => AtomType::FileType,
+            b"hdlr" => AtomType::Handler,
+            b"ilst" => AtomType::MetaList,
+            b"in24" => AtomType::S24SampleEntry,
+            b"in32" => AtomType::S32SampleEntry,
+            b"lpcm" => AtomType::Lpcm,
+            b"mdat" => AtomType::MediaData,
+            b"mdhd" => AtomType::MediaHeader,
+            b"mdia" => AtomType::Media,
+            b"mean" => AtomType::MetaTagMeaning,
+            b"mehd" => AtomType::MovieExtendsHeader,
+            b"meta" => AtomType::Meta,
+            b"mfhd" => AtomType::MovieFragmentHeader,
+            b"minf" => AtomType::MediaInfo,
+            b"moof" => AtomType::MovieFragment,
+            b"moov" => AtomType::Movie,
+            b"mp4a" => AtomType::Mp4a,
+            b"mvex" => AtomType::MovieExtends,
+            b"mvhd" => AtomType::MovieHeader,
+            b"name" => AtomType::MetaTagName,
+            b"Opus" => AtomType::Opus,
+            b"raw " => AtomType::U8SampleEntry,
+            b"sidx" => AtomType::SegmentIndex,
+            b"skip" => AtomType::Skip,
+            b"smhd" => AtomType::SoundMediaHeader,
+            b"sowt" => AtomType::S16LeSampleEntry,
+            b"stbl" => AtomType::SampleTable,
+            b"stco" => AtomType::ChunkOffset,
+            b"stsc" => AtomType::SampleToChunk,
+            b"stsd" => AtomType::SampleDescription,
+            b"stss" => AtomType::SyncSample,
+            b"stsz" => AtomType::SampleSize,
+            b"stts" => AtomType::TimeToSample,
+            b"tfhd" => AtomType::TrackFragmentHeader,
+            b"tkhd" => AtomType::TrackHeader,
+            b"traf" => AtomType::TrackFragment,
+            b"trak" => AtomType::Track,
+            b"trex" => AtomType::TrackExtends,
+            b"trun" => AtomType::TrackFragmentRun,
+            b"twos" => AtomType::S16BeSampleEntry,
+            b"udta" => AtomType::UserData,
+            b"ulaw" => AtomType::MuLaw,
+            b"wave" => AtomType::QtWave,
+            // Metadata Boxes
+            b"----" => AtomType::FreeFormTag,
+            b"aART" => AtomType::AlbumArtistTag,
+            b"catg" => AtomType::CategoryTag,
+            b"covr" => AtomType::CoverTag,
+            b"cpil" => AtomType::CompilationTag,
+            b"cprt" => AtomType::CopyrightTag,
+            b"desc" => AtomType::DescriptionTag,
+            b"disk" => AtomType::DiskNumberTag,
+            b"egid" => AtomType::IdentPodcastTag,
+            b"gnre" => AtomType::GenreTag,
+            b"hdvd" => AtomType::HdVideoTag,
+            b"keyw" => AtomType::KeywordTag,
+            b"ldes" => AtomType::LongDescriptionTag,
+            b"ownr" => AtomType::OwnerTag,
+            b"pcst" => AtomType::PodcastTag,
+            b"pgap" => AtomType::GaplessPlaybackTag,
+            b"purd" => AtomType::PurchaseDateTag,
+            b"purl" => AtomType::UrlPodcastTag,
+            b"rate" => AtomType::RatingTag,
+            b"rtng" => AtomType::AdvisoryTag,
+            b"soaa" => AtomType::SortAlbumArtistTag,
+            b"soal" => AtomType::SortAlbumTag,
+            b"soar" => AtomType::SortArtistTag,
+            b"soco" => AtomType::SortComposerTag,
+            b"sonm" => AtomType::SortNameTag,
+            b"stik" => AtomType::MediaTypeTag,
+            b"tmpo" => AtomType::TempoTag,
+            b"trkn" => AtomType::TrackNumberTag,
+            b"tven" => AtomType::TvEpisodeNameTag,
+            b"tves" => AtomType::TvEpisodeNumberTag,
+            b"tvnn" => AtomType::TvNetworkNameTag,
+            b"tvsh" => AtomType::TvShowNameTag,
+            b"tvsn" => AtomType::TvSeasonNumberTag,
+            b"\xa9alb" => AtomType::AlbumTag,
+            b"\xa9art" => AtomType::ArtistLowerTag,
+            b"\xa9ART" => AtomType::ArtistTag,
+            b"\xa9cmt" => AtomType::CommentTag,
+            b"\xa9day" => AtomType::DateTag,
+            b"\xa9enc" => AtomType::EncodedByTag,
+            b"\xa9gen" => AtomType::CustomGenreTag,
+            b"\xa9grp" => AtomType::GroupingTag,
+            b"\xa9lyr" => AtomType::LyricsTag,
+            b"\xa9nam" => AtomType::TrackTitleTag,
+            b"\xa9too" => AtomType::EncoderTag,
+            b"\xa9wrt" => AtomType::ComposerTag,
+            _ => AtomType::Other(val),
+        }
+    }
+}
+
+/// Common atom header.
+#[derive(Copy, Clone, Debug)]
+pub struct AtomHeader {
+    /// The atom type.
+    pub atype: AtomType,
+    /// The total size of the atom including the header.
+    pub atom_len: u64,
+    /// The size of the payload data.
+    pub data_len: u64,
+}
+
+impl AtomHeader {
+    const HEADER_SIZE: u64 = 8;
+    const EXTENDED_HEADER_SIZE: u64 = AtomHeader::HEADER_SIZE + 8;
+    const EXTRA_DATA_SIZE: u64 = 4;
+
+    /// Reads an atom header from the provided `ByteStream`.
+    pub fn read<B: ReadBytes>(reader: &mut B) -> Result<AtomHeader> {
+        let mut atom_len = u64::from(reader.read_be_u32()?);
+        let atype = AtomType::from(reader.read_quad_bytes()?);
+
+        let data_len = match atom_len {
+            0 => 0,
+            1 => {
+                atom_len = reader.read_be_u64()?;
+
+                // The atom size should be atleast the length of the header.
+                if atom_len < AtomHeader::EXTENDED_HEADER_SIZE {
+                    return decode_error("isomp4: atom size is invalid");
+                }
+
+                atom_len - AtomHeader::EXTENDED_HEADER_SIZE
+            }
+            _ => {
+                // The atom size should be atleast the length of the header.
+                if atom_len < AtomHeader::HEADER_SIZE {
+                    return decode_error("isomp4: atom size is invalid");
+                }
+
+                atom_len - AtomHeader::HEADER_SIZE
+            }
+        };
+
+        Ok(AtomHeader { atype, atom_len, data_len })
+    }
+
+    #[allow(dead_code)]
+    pub fn base_header_len(&self) -> u64 {
+        match self.atom_len {
+            0 => AtomHeader::HEADER_SIZE,
+            _ => self.atom_len - self.data_len,
+        }
+    }
+
+    /// For applicable atoms, reads the atom header extra data: a tuple composed of a u8 version
+    /// number, and a u24 bitset of flags.
+    pub fn read_extra<B: ReadBytes>(reader: &mut B) -> Result<(u8, u32)> {
+        Ok((reader.read_u8()?, reader.read_be_u24()?))
+    }
+}
+
+pub trait Atom: Sized {
+    #[allow(dead_code)]
+    fn header(&self) -> AtomHeader;
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self>;
+}
+
+pub struct AtomIterator<B: ReadBytes> {
+    reader: B,
+    len: Option<u64>,
+    cur_atom: Option<AtomHeader>,
+    base_pos: u64,
+    next_atom_pos: u64,
+}
+
+impl<B: ReadBytes> AtomIterator<B> {
+    pub fn new_root(reader: B, len: Option<u64>) -> Self {
+        let base_pos = reader.pos();
+
+        AtomIterator { reader, len, cur_atom: None, base_pos, next_atom_pos: base_pos }
+    }
+
+    pub fn new(reader: B, container: AtomHeader) -> Self {
+        let base_pos = reader.pos();
+
+        AtomIterator {
+            reader,
+            len: Some(container.data_len),
+            cur_atom: None,
+            base_pos,
+            next_atom_pos: base_pos,
+        }
+    }
+
+    pub fn into_inner(self) -> B {
+        self.reader
+    }
+
+    pub fn inner_mut(&mut self) -> &mut B {
+        &mut self.reader
+    }
+
+    pub fn next(&mut self) -> Result<Option<AtomHeader>> {
+        // Ignore any remaining data in the current atom that was not read.
+        let cur_pos = self.reader.pos();
+
+        if cur_pos < self.next_atom_pos {
+            self.reader.ignore_bytes(self.next_atom_pos - cur_pos)?;
+        }
+        else if cur_pos > self.next_atom_pos {
+            // This is very bad, either the atom's length was incorrect or the demuxer erroroneously
+            // overread an atom.
+            return decode_error("isomp4: overread atom");
+        }
+
+        // If len is specified, then do not read more than len bytes.
+        if let Some(len) = self.len {
+            if self.next_atom_pos - self.base_pos >= len {
+                return Ok(None);
+            }
+        }
+
+        // Read the next atom header.
+        let atom = AtomHeader::read(&mut self.reader)?;
+
+        // Calculate the start position for the next atom (the exclusive end of the current atom).
+        self.next_atom_pos = match atom.atom_len {
+            0 => {
+                // An atom with a length of zero is defined to span to the end of the stream. If
+                // len is available, use it for the next atom start position, otherwise, use u64 max
+                // which will trip an end of stream error on the next iteration.
+                self.len.map(|l| self.base_pos + l).unwrap_or(u64::MAX)
+            }
+
+            len => self.next_atom_pos + len,
+        };
+
+        self.cur_atom = Some(atom);
+
+        Ok(self.cur_atom)
+    }
+
+    pub fn next_no_consume(&mut self) -> Result<Option<AtomHeader>> {
+        if self.cur_atom.is_some() {
+            Ok(self.cur_atom)
+        }
+        else {
+            self.next()
+        }
+    }
+
+    pub fn read_atom<A: Atom>(&mut self) -> Result<A> {
+        // It is not possible to read the current atom more than once because ByteStream is not
+        // seekable. Therefore, raise an assert if read_atom is called more than once between calls
+        // to next, or after next returns None.
+        assert!(self.cur_atom.is_some());
+        A::read(&mut self.reader, self.cur_atom.take().unwrap())
+    }
+
+    pub fn consume_atom(&mut self) {
+        assert!(self.cur_atom.take().is_some());
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/moof.rs

@@ -0,0 +1,60 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType, MfhdAtom, TrafAtom};
+
+/// Movie fragment atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct MoofAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// The position of the first byte of this moof atom. This is used as the anchor point for the
+    /// subsequent track atoms.
+    pub moof_base_pos: u64,
+    /// Movie fragment header.
+    pub mfhd: MfhdAtom,
+    /// Track fragments.
+    pub trafs: Vec<TrafAtom>,
+}
+
+impl Atom for MoofAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let moof_base_pos = reader.pos() - AtomHeader::HEADER_SIZE;
+
+        let mut mfhd = None;
+        let mut trafs = Vec::new();
+
+        let mut iter = AtomIterator::new(reader, header);
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::MovieFragmentHeader => {
+                    mfhd = Some(iter.read_atom::<MfhdAtom>()?);
+                }
+                AtomType::TrackFragment => {
+                    let traf = iter.read_atom::<TrafAtom>()?;
+                    trafs.push(traf);
+                }
+                _ => (),
+            }
+        }
+
+        if mfhd.is_none() {
+            return decode_error("isomp4: missing mfhd atom");
+        }
+
+        Ok(MoofAtom { header, moof_base_pos, mfhd: mfhd.unwrap(), trafs })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/moov.rs

@@ -0,0 +1,103 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+use symphonia_core::meta::MetadataRevision;
+
+use crate::atoms::{
+    Atom, AtomHeader, AtomIterator, AtomType, MvexAtom, MvhdAtom, TrakAtom, UdtaAtom,
+};
+
+use log::warn;
+
+/// Movie atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct MoovAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Movie header atom.
+    pub mvhd: MvhdAtom,
+    /// Trak atoms.
+    pub traks: Vec<TrakAtom>,
+    /// Movie extends atom. The presence of this atom indicates a fragmented stream.
+    pub mvex: Option<MvexAtom>,
+    /// User data (usually metadata).
+    pub udta: Option<UdtaAtom>,
+}
+
+impl MoovAtom {
+    /// If metadata was read, consumes the metadata and returns it.
+    pub fn take_metadata(&mut self) -> Option<MetadataRevision> {
+        self.udta.as_mut().and_then(|udta| udta.take_metadata())
+    }
+
+    /// Is the movie segmented.
+    pub fn is_fragmented(&self) -> bool {
+        self.mvex.is_some()
+    }
+}
+
+impl Atom for MoovAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut mvhd = None;
+        let mut traks = Vec::new();
+        let mut mvex = None;
+        let mut udta = None;
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::MovieHeader => {
+                    mvhd = Some(iter.read_atom::<MvhdAtom>()?);
+                }
+                AtomType::Track => {
+                    // Gracefully skip malformed tracks (e.g. MJPEG cover-art streams
+                    // in older iTunes M4A files whose stbl or stsd may be missing
+                    // required atoms). The AtomIterator's next_atom_pos was already
+                    // set before read_atom was called, so a failure mid-parse still
+                    // leaves the iterator positioned at the end of this atom.
+                    match iter.read_atom::<TrakAtom>() {
+                        Ok(trak) => traks.push(trak),
+                        Err(e) => warn!("isomp4: skipping malformed trak atom: {}", e),
+                    }
+                }
+                AtomType::MovieExtends => {
+                    mvex = Some(iter.read_atom::<MvexAtom>()?);
+                }
+                AtomType::UserData => {
+                    udta = Some(iter.read_atom::<UdtaAtom>()?);
+                }
+                _ => (),
+            }
+        }
+
+        if mvhd.is_none() {
+            return decode_error("isomp4: missing mvhd atom");
+        }
+
+        // If fragmented, the mvex atom should contain a trex atom for each trak atom in moov.
+        if let Some(mvex) = mvex.as_ref() {
+            // For each trak, find a matching trex atom using the track id.
+            for trak in traks.iter() {
+                let found = mvex.trexs.iter().any(|trex| trex.track_id == trak.tkhd.id);
+
+                if !found {
+                    warn!("missing trex atom for trak with id={}", trak.tkhd.id);
+                }
+            }
+        }
+
+        Ok(MoovAtom { header, mvhd: mvhd.unwrap(), traks, mvex, udta })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/mvex.rs

@@ -0,0 +1,51 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType, MehdAtom, TrexAtom};
+
+/// Movie extends atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct MvexAtom {
+    /// Atom header.
+    pub header: AtomHeader,
+    /// Movie extends header, optional.
+    pub mehd: Option<MehdAtom>,
+    /// Track extends box, one per track.
+    pub trexs: Vec<TrexAtom>,
+}
+
+impl Atom for MvexAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut mehd = None;
+        let mut trexs = Vec::new();
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::MovieExtendsHeader => {
+                    mehd = Some(iter.read_atom::<MehdAtom>()?);
+                }
+                AtomType::TrackExtends => {
+                    let trex = iter.read_atom::<TrexAtom>()?;
+                    trexs.push(trex);
+                }
+                _ => (),
+            }
+        }
+
+        Ok(MvexAtom { header, mehd, trexs })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/mvhd.rs

@@ -0,0 +1,80 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+use crate::fp::FpU8;
+
+/// Movie header atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct MvhdAtom {
+    /// Atom header.
+    pub header: AtomHeader,
+    /// The creation time.
+    pub ctime: u64,
+    /// The modification time.
+    pub mtime: u64,
+    /// Timescale for the movie expressed as the number of units per second.
+    pub timescale: u32,
+    /// The duration of the movie in `timescale` units.
+    pub duration: u64,
+    /// The preferred volume to play the movie.
+    pub volume: FpU8,
+}
+
+impl Atom for MvhdAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (version, _) = AtomHeader::read_extra(reader)?;
+
+        let mut mvhd = MvhdAtom {
+            header,
+            ctime: 0,
+            mtime: 0,
+            timescale: 0,
+            duration: 0,
+            volume: Default::default(),
+        };
+
+        // Version 0 uses 32-bit time values, verion 1 used 64-bit values.
+        match version {
+            0 => {
+                mvhd.ctime = u64::from(reader.read_be_u32()?);
+                mvhd.mtime = u64::from(reader.read_be_u32()?);
+                mvhd.timescale = reader.read_be_u32()?;
+                // 0xffff_ffff is a special case.
+                mvhd.duration = match reader.read_be_u32()? {
+                    u32::MAX => u64::MAX,
+                    duration => u64::from(duration),
+                };
+            }
+            1 => {
+                mvhd.ctime = reader.read_be_u64()?;
+                mvhd.mtime = reader.read_be_u64()?;
+                mvhd.timescale = reader.read_be_u32()?;
+                mvhd.duration = reader.read_be_u64()?;
+            }
+            _ => return decode_error("isomp4: invalid mvhd version"),
+        }
+
+        // Ignore the preferred playback rate.
+        let _ = reader.read_be_u32()?;
+
+        // Preferred volume.
+        mvhd.volume = FpU8::parse_raw(reader.read_be_u16()?);
+
+        // Remaining fields are ignored.
+
+        Ok(mvhd)
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/opus.rs

@@ -0,0 +1,72 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::codecs::{CodecParameters, CODEC_TYPE_OPUS};
+use symphonia_core::errors::{decode_error, unsupported_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct OpusAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Opus extra data (identification header).
+    extra_data: Box<[u8]>,
+}
+
+impl Atom for OpusAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        const OPUS_MAGIC: &[u8] = b"OpusHead";
+        const OPUS_MAGIC_LEN: usize = OPUS_MAGIC.len();
+
+        const MIN_OPUS_EXTRA_DATA_SIZE: usize = OPUS_MAGIC_LEN + 11;
+        const MAX_OPUS_EXTRA_DATA_SIZE: usize = MIN_OPUS_EXTRA_DATA_SIZE + 257;
+
+        // Offset of the Opus version number in the extra data.
+        const OPUS_EXTRADATA_VERSION_OFFSET: usize = OPUS_MAGIC_LEN;
+
+        // The dops atom contains an Opus identification header excluding the OpusHead magic
+        // signature. Therefore, the atom data length should be atleast as long as the shortest
+        // Opus identification header.
+        let data_len = header.data_len as usize;
+
+        if data_len < MIN_OPUS_EXTRA_DATA_SIZE - OPUS_MAGIC_LEN {
+            return decode_error("isomp4 (opus): opus identification header too short");
+        }
+
+        if data_len > MAX_OPUS_EXTRA_DATA_SIZE - OPUS_MAGIC_LEN {
+            return decode_error("isomp4 (opus): opus identification header too large");
+        }
+
+        let mut extra_data = vec![0; OPUS_MAGIC_LEN + data_len].into_boxed_slice();
+
+        // The Opus magic is excluded in the atom, but the extra data must start with it.
+        extra_data[..OPUS_MAGIC_LEN].copy_from_slice(OPUS_MAGIC);
+
+        // Read the extra data from the atom.
+        reader.read_buf_exact(&mut extra_data[OPUS_MAGIC_LEN..])?;
+
+        // Verify the version number is 0.
+        if extra_data[OPUS_EXTRADATA_VERSION_OFFSET] != 0 {
+            return unsupported_error("isomp4 (opus): unsupported opus version");
+        }
+
+        Ok(OpusAtom { header, extra_data })
+    }
+}
+
+impl OpusAtom {
+    pub fn fill_codec_params(&self, codec_params: &mut CodecParameters) {
+        codec_params.for_codec(CODEC_TYPE_OPUS).with_extra_data(self.extra_data.clone());
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/sidx.rs

@@ -0,0 +1,89 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+#[derive(Debug)]
+pub enum ReferenceType {
+    Segment,
+    Media,
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct SidxReference {
+    pub reference_type: ReferenceType,
+    pub reference_size: u32,
+    pub subsegment_duration: u32,
+    // pub starts_with_sap: bool,
+    // pub sap_type: u8,
+    // pub sap_delta_time: u32,
+}
+
+/// Segment index atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct SidxAtom {
+    /// Atom header.
+    header: AtomHeader,
+    pub reference_id: u32,
+    pub timescale: u32,
+    pub earliest_pts: u64,
+    pub first_offset: u64,
+    pub references: Vec<SidxReference>,
+}
+
+impl Atom for SidxAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        // The anchor point for segment offsets is the first byte after this atom.
+        let anchor = reader.pos() + header.data_len;
+
+        let (version, _) = AtomHeader::read_extra(reader)?;
+
+        let reference_id = reader.read_be_u32()?;
+        let timescale = reader.read_be_u32()?;
+
+        let (earliest_pts, first_offset) = match version {
+            0 => (u64::from(reader.read_be_u32()?), anchor + u64::from(reader.read_be_u32()?)),
+            1 => (reader.read_be_u64()?, anchor + reader.read_be_u64()?),
+            _ => {
+                return decode_error("isomp4: invalid sidx version");
+            }
+        };
+
+        let _reserved = reader.read_be_u16()?;
+        let reference_count = reader.read_be_u16()?;
+
+        let mut references = Vec::new();
+
+        for _ in 0..reference_count {
+            let reference = reader.read_be_u32()?;
+            let subsegment_duration = reader.read_be_u32()?;
+
+            let reference_type = match (reference & 0x8000_0000) != 0 {
+                false => ReferenceType::Media,
+                true => ReferenceType::Segment,
+            };
+
+            let reference_size = reference & !0x8000_0000;
+
+            // Ignore SAP
+            let _ = reader.read_be_u32()?;
+
+            references.push(SidxReference { reference_type, reference_size, subsegment_duration });
+        }
+
+        Ok(SidxAtom { header, reference_id, timescale, earliest_pts, first_offset, references })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/smhd.rs

@@ -0,0 +1,40 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+use crate::fp::FpI8;
+
+/// Sound header atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct SmhdAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Stereo balance.
+    pub balance: FpI8,
+}
+
+impl Atom for SmhdAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        // Stereo balance
+        let balance = FpI8::parse_raw(reader.read_be_u16()? as i16);
+
+        // Reserved.
+        let _ = reader.read_be_u16()?;
+
+        Ok(SmhdAtom { header, balance })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/stbl.rs

@@ -0,0 +1,108 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType};
+use crate::atoms::{Co64Atom, StcoAtom, StscAtom, StsdAtom, StszAtom, SttsAtom};
+
+use log::warn;
+
+/// Sample table atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct StblAtom {
+    /// Atom header.
+    header: AtomHeader,
+    pub stsd: StsdAtom,
+    pub stts: SttsAtom,
+    pub stsc: StscAtom,
+    pub stsz: StszAtom,
+    pub stco: Option<StcoAtom>,
+    pub co64: Option<Co64Atom>,
+}
+
+impl Atom for StblAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut stsd = None;
+        let mut stts = None;
+        let mut stsc = None;
+        let mut stsz = None;
+        let mut stco = None;
+        let mut co64 = None;
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::SampleDescription => {
+                    stsd = Some(iter.read_atom::<StsdAtom>()?);
+                }
+                AtomType::TimeToSample => {
+                    stts = Some(iter.read_atom::<SttsAtom>()?);
+                }
+                AtomType::CompositionTimeToSample => {
+                    // Composition time to sample atom is only required for video.
+                    warn!("ignoring ctts atom.");
+                }
+                AtomType::SyncSample => {
+                    // Sync sample atom is only required for video.
+                    warn!("ignoring stss atom.");
+                }
+                AtomType::SampleToChunk => {
+                    stsc = Some(iter.read_atom::<StscAtom>()?);
+                }
+                AtomType::SampleSize => {
+                    stsz = Some(iter.read_atom::<StszAtom>()?);
+                }
+                AtomType::ChunkOffset => {
+                    stco = Some(iter.read_atom::<StcoAtom>()?);
+                }
+                AtomType::ChunkOffset64 => {
+                    co64 = Some(iter.read_atom::<Co64Atom>()?);
+                }
+                _ => (),
+            }
+        }
+
+        if stsd.is_none() {
+            return decode_error("isomp4: missing stsd atom");
+        }
+
+        if stts.is_none() {
+            return decode_error("isomp4: missing stts atom");
+        }
+
+        if stsc.is_none() {
+            return decode_error("isomp4: missing stsc atom");
+        }
+
+        if stsz.is_none() {
+            return decode_error("isomp4: missing stsz atom");
+        }
+
+        if stco.is_none() && co64.is_none() {
+            // This is a spec. violation, but some m4a files appear to lack these atoms.
+            warn!("missing stco or co64 atom");
+        }
+
+        Ok(StblAtom {
+            header,
+            stsd: stsd.unwrap(),
+            stts: stts.unwrap(),
+            stsc: stsc.unwrap(),
+            stsz: stsz.unwrap(),
+            stco,
+            co64,
+        })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/stco.rs

@@ -0,0 +1,41 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+/// Chunk offset atom (32-bit version).
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct StcoAtom {
+    /// Atom header.
+    header: AtomHeader,
+    pub chunk_offsets: Vec<u32>,
+}
+
+impl Atom for StcoAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        let entry_count = reader.read_be_u32()?;
+
+        // TODO: Apply a limit.
+        let mut chunk_offsets = Vec::with_capacity(entry_count as usize);
+
+        for _ in 0..entry_count {
+            chunk_offsets.push(reader.read_be_u32()?);
+        }
+
+        Ok(StcoAtom { header, chunk_offsets })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/stsc.rs

@@ -0,0 +1,109 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct StscEntry {
+    pub first_chunk: u32,
+    pub first_sample: u32,
+    pub samples_per_chunk: u32,
+    pub sample_desc_index: u32,
+}
+
+/// Sample to Chunk Atom
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct StscAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Entries.
+    pub entries: Vec<StscEntry>,
+}
+
+impl StscAtom {
+    /// Finds the `StscEntry` for the sample indicated by `sample_num`. Note, `sample_num` is indexed
+    /// relative to the `StscAtom`. Complexity is O(log2 N).
+    pub fn find_entry_for_sample(&self, sample_num: u32) -> Option<&StscEntry> {
+        let mut left = 1;
+        let mut right = self.entries.len();
+
+        while left < right {
+            let mid = left + (right - left) / 2;
+
+            let entry = self.entries.get(mid).unwrap();
+
+            if entry.first_sample < sample_num {
+                left = mid + 1;
+            }
+            else {
+                right = mid;
+            }
+        }
+
+        // The index found above (left) is the exclusive upper bound of all entries where
+        // first_sample < sample_num. Therefore, the entry to return has an index of left-1. The
+        // index will never equal 0 so this is safe. If the table were empty, left == 1, thus calling
+        // get with an index of 0, and safely returning None.
+        self.entries.get(left - 1)
+    }
+}
+
+impl Atom for StscAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        let entry_count = reader.read_be_u32()?;
+
+        // TODO: Apply a limit.
+        let mut entries = Vec::with_capacity(entry_count as usize);
+
+        for _ in 0..entry_count {
+            entries.push(StscEntry {
+                first_chunk: reader.read_be_u32()? - 1,
+                first_sample: 0,
+                samples_per_chunk: reader.read_be_u32()?,
+                sample_desc_index: reader.read_be_u32()?,
+            });
+        }
+
+        // Post-process entries to check for errors and calculate the file sample.
+        if entry_count > 0 {
+            for i in 0..entry_count as usize - 1 {
+                // Validate that first_chunk is monotonic across all entries.
+                if entries[i + 1].first_chunk < entries[i].first_chunk {
+                    return decode_error("isomp4: stsc entry first chunk not monotonic");
+                }
+
+                // Validate that samples per chunk is > 0. Could the entry be ignored?
+                if entries[i].samples_per_chunk == 0 {
+                    return decode_error("isomp4: stsc entry has 0 samples per chunk");
+                }
+
+                let n = entries[i + 1].first_chunk - entries[i].first_chunk;
+
+                entries[i + 1].first_sample =
+                    entries[i].first_sample + (n * entries[i].samples_per_chunk);
+            }
+
+            // Validate that samples per chunk is > 0. Could the entry be ignored?
+            if entries[entry_count as usize - 1].samples_per_chunk == 0 {
+                return decode_error("isomp4: stsc entry has 0 samples per chunk");
+            }
+        }
+
+        Ok(StscAtom { header, entries })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/stsd.rs

@@ -0,0 +1,539 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::audio::Channels;
+use symphonia_core::codecs::{CodecParameters, CodecType, CODEC_TYPE_MP3, CODEC_TYPE_NULL};
+use symphonia_core::codecs::{CODEC_TYPE_PCM_F32BE, CODEC_TYPE_PCM_F32LE};
+use symphonia_core::codecs::{CODEC_TYPE_PCM_F64BE, CODEC_TYPE_PCM_F64LE};
+use symphonia_core::codecs::{CODEC_TYPE_PCM_S16BE, CODEC_TYPE_PCM_S16LE};
+use symphonia_core::codecs::{CODEC_TYPE_PCM_S24BE, CODEC_TYPE_PCM_S24LE};
+use symphonia_core::codecs::{CODEC_TYPE_PCM_S32BE, CODEC_TYPE_PCM_S32LE};
+use symphonia_core::codecs::{CODEC_TYPE_PCM_S8, CODEC_TYPE_PCM_U8};
+use symphonia_core::codecs::{CODEC_TYPE_PCM_U16BE, CODEC_TYPE_PCM_U16LE};
+use symphonia_core::codecs::{CODEC_TYPE_PCM_U24BE, CODEC_TYPE_PCM_U24LE};
+use symphonia_core::codecs::{CODEC_TYPE_PCM_U32BE, CODEC_TYPE_PCM_U32LE};
+use symphonia_core::errors::{decode_error, unsupported_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{AlacAtom, Atom, AtomHeader, AtomType, EsdsAtom, FlacAtom, OpusAtom, WaveAtom};
+use crate::fp::FpU16;
+
+use super::AtomIterator;
+
+/// Sample description atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct StsdAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Sample entry.
+    sample_entry: SampleEntry,
+}
+
+impl Atom for StsdAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        let n_entries = reader.read_be_u32()?;
+
+        if n_entries == 0 {
+            return decode_error("isomp4: missing sample entry");
+        }
+
+        if n_entries > 1 {
+            return unsupported_error("isomp4: more than 1 sample entry");
+        }
+
+        let sample_entry_header = AtomHeader::read(reader)?;
+
+        let sample_entry = match sample_entry_header.atype {
+            AtomType::Mp4a
+            | AtomType::Alac
+            | AtomType::Flac
+            | AtomType::Opus
+            | AtomType::Mp3
+            | AtomType::Lpcm
+            | AtomType::QtWave
+            | AtomType::ALaw
+            | AtomType::MuLaw
+            | AtomType::U8SampleEntry
+            | AtomType::S16LeSampleEntry
+            | AtomType::S16BeSampleEntry
+            | AtomType::S24SampleEntry
+            | AtomType::S32SampleEntry
+            | AtomType::F32SampleEntry
+            | AtomType::F64SampleEntry => read_audio_sample_entry(reader, sample_entry_header)?,
+            _ => {
+                // Potentially video, subtitles, etc.
+                SampleEntry::Other
+            }
+        };
+
+        Ok(StsdAtom { header, sample_entry })
+    }
+}
+
+impl StsdAtom {
+    /// Fill the provided `CodecParameters` using the sample entry.
+    pub fn fill_codec_params(&self, codec_params: &mut CodecParameters) {
+        // Audio sample entry.
+        if let SampleEntry::Audio(ref entry) = self.sample_entry {
+            // General audio parameters.
+            codec_params.with_sample_rate(entry.sample_rate as u32);
+
+            // Codec-specific parameters.
+            match entry.codec_specific {
+                Some(AudioCodecSpecific::Esds(ref esds)) => {
+                    esds.fill_codec_params(codec_params);
+                }
+                Some(AudioCodecSpecific::Alac(ref alac)) => {
+                    alac.fill_codec_params(codec_params);
+                }
+                Some(AudioCodecSpecific::Flac(ref flac)) => {
+                    flac.fill_codec_params(codec_params);
+                }
+                Some(AudioCodecSpecific::Opus(ref opus)) => {
+                    opus.fill_codec_params(codec_params);
+                }
+                Some(AudioCodecSpecific::Mp3) => {
+                    codec_params.for_codec(CODEC_TYPE_MP3);
+                }
+                Some(AudioCodecSpecific::Pcm(ref pcm)) => {
+                    // PCM codecs.
+                    codec_params
+                        .for_codec(pcm.codec_type)
+                        .with_bits_per_coded_sample(pcm.bits_per_coded_sample)
+                        .with_bits_per_sample(pcm.bits_per_sample)
+                        .with_max_frames_per_packet(pcm.frames_per_packet)
+                        .with_channels(pcm.channels);
+                }
+                _ => (),
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Pcm {
+    pub codec_type: CodecType,
+    pub bits_per_sample: u32,
+    pub bits_per_coded_sample: u32,
+    pub frames_per_packet: u64,
+    pub channels: Channels,
+}
+
+#[derive(Debug)]
+pub enum AudioCodecSpecific {
+    /// MPEG Elementary Stream descriptor.
+    Esds(EsdsAtom),
+    /// Apple Lossless Audio Codec (ALAC).
+    Alac(AlacAtom),
+    /// Free Lossless Audio Codec (FLAC).
+    Flac(FlacAtom),
+    /// Opus.
+    Opus(OpusAtom),
+    /// MP3.
+    Mp3,
+    /// PCM codecs.
+    Pcm(Pcm),
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct AudioSampleEntry {
+    pub num_channels: u32,
+    pub sample_size: u16,
+    pub sample_rate: f64,
+    pub codec_specific: Option<AudioCodecSpecific>,
+}
+
+#[derive(Debug)]
+pub enum SampleEntry {
+    Audio(AudioSampleEntry),
+    // Video,
+    // Metadata,
+    Other,
+}
+
+/// Gets if the sample entry atom is for a PCM codec.
+fn is_pcm_codec(atype: AtomType) -> bool {
+    // PCM data in version 0 and 1 is signalled by the sample entry atom type. In version 2, the
+    // atom type for PCM data is always LPCM.
+    atype == AtomType::Lpcm || pcm_codec_type(atype) != CODEC_TYPE_NULL
+}
+
+/// Gets the PCM codec from the sample entry atom type for version 0 and 1 sample entries.
+fn pcm_codec_type(atype: AtomType) -> CodecType {
+    match atype {
+        AtomType::U8SampleEntry => CODEC_TYPE_PCM_U8,
+        AtomType::S16LeSampleEntry => CODEC_TYPE_PCM_S16LE,
+        AtomType::S16BeSampleEntry => CODEC_TYPE_PCM_S16BE,
+        AtomType::S24SampleEntry => CODEC_TYPE_PCM_S24LE,
+        AtomType::S32SampleEntry => CODEC_TYPE_PCM_S32LE,
+        AtomType::F32SampleEntry => CODEC_TYPE_PCM_F32LE,
+        AtomType::F64SampleEntry => CODEC_TYPE_PCM_F64LE,
+        _ => CODEC_TYPE_NULL,
+    }
+}
+
+/// Determines the number of bytes per PCM sample for a PCM codec type.
+fn bytes_per_pcm_sample(pcm_codec_type: CodecType) -> u32 {
+    match pcm_codec_type {
+        CODEC_TYPE_PCM_S8 | CODEC_TYPE_PCM_U8 => 1,
+        CODEC_TYPE_PCM_S16BE | CODEC_TYPE_PCM_S16LE => 2,
+        CODEC_TYPE_PCM_U16BE | CODEC_TYPE_PCM_U16LE => 2,
+        CODEC_TYPE_PCM_S24BE | CODEC_TYPE_PCM_S24LE => 3,
+        CODEC_TYPE_PCM_U24BE | CODEC_TYPE_PCM_U24LE => 3,
+        CODEC_TYPE_PCM_S32BE | CODEC_TYPE_PCM_S32LE => 4,
+        CODEC_TYPE_PCM_U32BE | CODEC_TYPE_PCM_U32LE => 4,
+        CODEC_TYPE_PCM_F32BE | CODEC_TYPE_PCM_F32LE => 4,
+        CODEC_TYPE_PCM_F64BE | CODEC_TYPE_PCM_F64LE => 8,
+        _ => unreachable!(),
+    }
+}
+
+/// Gets the PCM codec from the LPCM parameters in the version 2 sample entry atom.
+fn lpcm_codec_type(bits_per_sample: u32, lpcm_flags: u32) -> CodecType {
+    let is_floating_point = lpcm_flags & 0x1 != 0;
+    let is_big_endian = lpcm_flags & 0x2 != 0;
+    let is_signed = lpcm_flags & 0x4 != 0;
+
+    if is_floating_point {
+        // Floating-point sample format.
+        match bits_per_sample {
+            32 => {
+                if is_big_endian {
+                    CODEC_TYPE_PCM_F32BE
+                }
+                else {
+                    CODEC_TYPE_PCM_F32LE
+                }
+            }
+            64 => {
+                if is_big_endian {
+                    CODEC_TYPE_PCM_F64BE
+                }
+                else {
+                    CODEC_TYPE_PCM_F64LE
+                }
+            }
+            _ => CODEC_TYPE_NULL,
+        }
+    }
+    else {
+        // Integer sample format.
+        if is_signed {
+            // Signed-integer sample format.
+            match bits_per_sample {
+                8 => CODEC_TYPE_PCM_S8,
+                16 => {
+                    if is_big_endian {
+                        CODEC_TYPE_PCM_S16BE
+                    }
+                    else {
+                        CODEC_TYPE_PCM_S16LE
+                    }
+                }
+                24 => {
+                    if is_big_endian {
+                        CODEC_TYPE_PCM_S24BE
+                    }
+                    else {
+                        CODEC_TYPE_PCM_S24LE
+                    }
+                }
+                32 => {
+                    if is_big_endian {
+                        CODEC_TYPE_PCM_S32BE
+                    }
+                    else {
+                        CODEC_TYPE_PCM_S32LE
+                    }
+                }
+                _ => CODEC_TYPE_NULL,
+            }
+        }
+        else {
+            // Unsigned-integer sample format.
+            match bits_per_sample {
+                8 => CODEC_TYPE_PCM_U8,
+                16 => {
+                    if is_big_endian {
+                        CODEC_TYPE_PCM_U16BE
+                    }
+                    else {
+                        CODEC_TYPE_PCM_U16LE
+                    }
+                }
+                24 => {
+                    if is_big_endian {
+                        CODEC_TYPE_PCM_U24BE
+                    }
+                    else {
+                        CODEC_TYPE_PCM_U24LE
+                    }
+                }
+                32 => {
+                    if is_big_endian {
+                        CODEC_TYPE_PCM_U32BE
+                    }
+                    else {
+                        CODEC_TYPE_PCM_U32LE
+                    }
+                }
+                _ => CODEC_TYPE_NULL,
+            }
+        }
+    }
+}
+
+/// Gets the audio channels for a version 0 or 1 sample entry.
+fn pcm_channels(num_channels: u32) -> Result<Channels> {
+    match num_channels {
+        1 => Ok(Channels::FRONT_LEFT),
+        2 => Ok(Channels::FRONT_LEFT | Channels::FRONT_RIGHT),
+        _ => decode_error("isomp4: invalid number of channels"),
+    }
+}
+
+/// Gets the audio channels for a version 2 LPCM sample entry.
+fn lpcm_channels(num_channels: u32) -> Result<Channels> {
+    if num_channels < 1 {
+        return decode_error("isomp4: invalid number of channels");
+    }
+
+    if num_channels > 32 {
+        return unsupported_error("isomp4: maximum 32 channels");
+    }
+
+    // TODO: For LPCM, the channels are "auxilary". They do not have a speaker assignment. Symphonia
+    // does not have a way to represent this yet.
+    let channel_mask = !((!0 << 1) << (num_channels - 1));
+
+    match Channels::from_bits(channel_mask) {
+        Some(channels) => Ok(channels),
+        _ => unsupported_error("isomp4: unsupported number of channels"),
+    }
+}
+
+fn read_audio_sample_entry<B: ReadBytes>(
+    reader: &mut B,
+    mut header: AtomHeader,
+) -> Result<SampleEntry> {
+    // An audio sample entry atom is derived from a base sample entry atom. The audio sample entry
+    // atom contains the fields of the base sample entry first, then the audio sample entry fields
+    // next. After those fields, a number of other atoms are nested, including the mandatory
+    // codec-specific atom. Though the codec-specific atom is nested within the (audio) sample entry
+    // atom, the (audio) sample entry atom uses the atom type of the codec-specific atom. This is
+    // odd in-that the final structure will appear to have the codec-specific atom nested within
+    // itself, which is not actually the case.
+
+    let data_start_pos = reader.pos();
+
+    // First 6 bytes of all sample entries should be all 0.
+    reader.ignore_bytes(6)?;
+
+    // Sample entry data reference.
+    let _ = reader.read_be_u16()?;
+
+    // The version of the audio sample entry.
+    let version = reader.read_be_u16()?;
+
+    // Skip revision and vendor.
+    reader.ignore_bytes(6)?;
+
+    let mut num_channels = u32::from(reader.read_be_u16()?);
+    let sample_size = reader.read_be_u16()?;
+
+    // Skip compression ID and packet size.
+    reader.ignore_bytes(4)?;
+
+    let mut sample_rate = f64::from(FpU16::parse_raw(reader.read_be_u32()?));
+
+    let is_pcm_codec = is_pcm_codec(header.atype);
+
+    let mut codec_specific = match version {
+        0 => {
+            // Version 0.
+            if is_pcm_codec {
+                let codec_type = pcm_codec_type(header.atype);
+                let bits_per_sample = 8 * bytes_per_pcm_sample(codec_type);
+
+                // Validate the codec-derived bytes-per-sample equals the declared bytes-per-sample.
+                if u32::from(sample_size) != bits_per_sample {
+                    return decode_error("isomp4: invalid pcm sample size");
+                }
+
+                // The original fields describe the PCM sample format.
+                Some(AudioCodecSpecific::Pcm(Pcm {
+                    codec_type: pcm_codec_type(header.atype),
+                    bits_per_sample,
+                    bits_per_coded_sample: bits_per_sample,
+                    frames_per_packet: 1,
+                    channels: pcm_channels(num_channels)?,
+                }))
+            }
+            else {
+                None
+            }
+        }
+        1 => {
+            // Version 1.
+
+            // The number of frames (ISO/MP4 samples) per packet. For PCM codecs, this is always 1.
+            let _frames_per_packet = reader.read_be_u32()?;
+
+            // The number of bytes per PCM audio sample. This value supersedes sample_size. For
+            // non-PCM codecs, this value is not useful.
+            let bytes_per_audio_sample = reader.read_be_u32()?;
+
+            // The number of bytes per PCM audio frame (ISO/MP4 sample). For non-PCM codecs, this
+            // value is not useful.
+            let _bytes_per_frame = reader.read_be_u32()?;
+
+            // The next value, as defined, is seemingly non-sensical.
+            let _ = reader.read_be_u32()?;
+
+            if is_pcm_codec {
+                let codec_type = pcm_codec_type(header.atype);
+                let codec_bytes_per_sample = bytes_per_pcm_sample(codec_type);
+
+                // Validate the codec-derived bytes-per-sample equals the declared bytes-per-sample.
+                if bytes_per_audio_sample != codec_bytes_per_sample {
+                    return decode_error("isomp4: invalid pcm bytes per sample");
+                }
+
+                // The new fields describe the PCM sample format and supersede the original version
+                // 0 fields.
+                Some(AudioCodecSpecific::Pcm(Pcm {
+                    codec_type,
+                    bits_per_sample: 8 * codec_bytes_per_sample,
+                    bits_per_coded_sample: 8 * codec_bytes_per_sample,
+                    frames_per_packet: 1,
+                    channels: pcm_channels(num_channels)?,
+                }))
+            }
+            else {
+                None
+            }
+        }
+        2 => {
+            // Version 2.
+            reader.ignore_bytes(4)?;
+
+            sample_rate = reader.read_be_f64()?;
+            num_channels = reader.read_be_u32()?;
+
+            if reader.read_be_u32()? != 0x7f00_0000 {
+                return decode_error("isomp4: audio sample entry v2 reserved must be 0x7f00_0000");
+            }
+
+            // The following fields are only useful for PCM codecs.
+            let bits_per_sample = reader.read_be_u32()?;
+            let lpcm_flags = reader.read_be_u32()?;
+            let _bytes_per_packet = reader.read_be_u32()?;
+            let lpcm_frames_per_packet = reader.read_be_u32()?;
+
+            // This is only valid if this is a PCM codec.
+            let codec_type = lpcm_codec_type(bits_per_sample, lpcm_flags);
+
+            if is_pcm_codec && codec_type != CODEC_TYPE_NULL {
+                // Like version 1, the new fields describe the PCM sample format and supersede the
+                // original version 0 fields.
+                Some(AudioCodecSpecific::Pcm(Pcm {
+                    codec_type,
+                    bits_per_sample,
+                    bits_per_coded_sample: bits_per_sample,
+                    frames_per_packet: u64::from(lpcm_frames_per_packet),
+                    channels: lpcm_channels(num_channels)?,
+                }))
+            }
+            else {
+                None
+            }
+        }
+        _ => {
+            return unsupported_error("isomp4: unknown sample entry version");
+        }
+    };
+
+    // Need to account for the data already read from the atom.
+    header.data_len -= reader.pos() - data_start_pos;
+
+    let mut iter = AtomIterator::new(reader, header);
+
+    while let Some(entry_header) = iter.next()? {
+        match entry_header.atype {
+            AtomType::Esds => {
+                // MP4A/ESDS codec-specific atom.
+                if header.atype != AtomType::Mp4a || codec_specific.is_some() {
+                    return decode_error("isomp4: invalid sample entry");
+                }
+
+                codec_specific = Some(AudioCodecSpecific::Esds(iter.read_atom::<EsdsAtom>()?));
+            }
+            AtomType::Alac => {
+                // ALAC codec-specific atom.
+                if header.atype != AtomType::Alac || codec_specific.is_some() {
+                    return decode_error("isomp4: invalid sample entry");
+                }
+
+                codec_specific = Some(AudioCodecSpecific::Alac(iter.read_atom::<AlacAtom>()?));
+            }
+            AtomType::FlacDsConfig => {
+                // FLAC codec-specific atom.
+                if header.atype != AtomType::Flac || codec_specific.is_some() {
+                    return decode_error("isomp4: invalid sample entry");
+                }
+
+                codec_specific = Some(AudioCodecSpecific::Flac(iter.read_atom::<FlacAtom>()?));
+            }
+            AtomType::OpusDsConfig => {
+                // Opus codec-specific atom.
+                if header.atype != AtomType::Opus || codec_specific.is_some() {
+                    return decode_error("isomp4: invalid sample entry");
+                }
+
+                codec_specific = Some(AudioCodecSpecific::Opus(iter.read_atom::<OpusAtom>()?));
+            }
+            AtomType::QtWave => {
+                // The QuickTime WAVE (aka. siDecompressionParam) atom may contain many different
+                // types of sub-atoms to store decoder parameters.
+                let wave = iter.read_atom::<WaveAtom>()?;
+
+                if let Some(esds) = wave.esds {
+                    if codec_specific.is_some() {
+                        return decode_error("isomp4: invalid sample entry");
+                    }
+
+                    codec_specific = Some(AudioCodecSpecific::Esds(esds));
+                }
+            }
+            _ => (),
+        }
+    }
+
+    // A MP3 sample entry has no codec-specific atom.
+    if header.atype == AtomType::Mp3 {
+        if codec_specific.is_some() {
+            return decode_error("isomp4: invalid sample entry");
+        }
+
+        codec_specific = Some(AudioCodecSpecific::Mp3);
+    }
+
+    Ok(SampleEntry::Audio(AudioSampleEntry {
+        num_channels,
+        sample_size,
+        sample_rate,
+        codec_specific,
+    }))
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/stss.rs

@@ -0,0 +1,28 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct StssAtom {
+    /// Atom header.
+    header: AtomHeader,
+}
+
+impl Atom for StssAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(_reader: &mut B, _header: AtomHeader) -> Result<Self> {
+        todo!()
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/stsz.rs

@@ -0,0 +1,58 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+#[derive(Debug)]
+pub enum SampleSize {
+    Constant(u32),
+    Variable(Vec<u32>),
+}
+
+/// Sample Size Atom
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct StszAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// The total number of samples.
+    pub sample_count: u32,
+    /// A vector of `sample_count` sample sizes, or a constant size for all samples.
+    pub sample_sizes: SampleSize,
+}
+
+impl Atom for StszAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        let sample_size = reader.read_be_u32()?;
+        let sample_count = reader.read_be_u32()?;
+
+        let sample_sizes = if sample_size == 0 {
+            // TODO: Apply a limit.
+            let mut entries = Vec::with_capacity(sample_count as usize);
+
+            for _ in 0..sample_count {
+                entries.push(reader.read_be_u32()?);
+            }
+
+            SampleSize::Variable(entries)
+        }
+        else {
+            SampleSize::Constant(sample_size)
+        };
+
+        Ok(StszAtom { header, sample_count, sample_sizes })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/stts.rs

@@ -0,0 +1,105 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+#[derive(Debug)]
+pub struct SampleDurationEntry {
+    pub sample_count: u32,
+    pub sample_delta: u32,
+}
+
+/// Time-to-sample atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct SttsAtom {
+    /// Atom header.
+    header: AtomHeader,
+    pub entries: Vec<SampleDurationEntry>,
+    pub total_duration: u64,
+}
+
+impl SttsAtom {
+    /// Get the timestamp and duration for the sample indicated by `sample_num`. Note, `sample_num`
+    /// is indexed relative to the `SttsAtom`. Complexity of this function in O(N).
+    pub fn find_timing_for_sample(&self, sample_num: u32) -> Option<(u64, u32)> {
+        let mut ts = 0;
+        let mut next_entry_first_sample = 0;
+
+        // The Stts atom compactly encodes a mapping between number of samples and sample duration.
+        // Iterate through each entry until the entry containing the next sample is found. The next
+        // packet timestamp is then the sum of the product of sample count and sample duration for
+        // the n-1 iterated entries, plus the product of the number of consumed samples in the n-th
+        // iterated entry and sample duration.
+        for entry in &self.entries {
+            next_entry_first_sample += entry.sample_count;
+
+            if sample_num < next_entry_first_sample {
+                let entry_sample_offset = sample_num + entry.sample_count - next_entry_first_sample;
+                ts += u64::from(entry.sample_delta) * u64::from(entry_sample_offset);
+
+                return Some((ts, entry.sample_delta));
+            }
+
+            ts += u64::from(entry.sample_count) * u64::from(entry.sample_delta);
+        }
+
+        None
+    }
+
+    /// Get the sample that contains the timestamp indicated by `ts`. Note, the returned `sample_num`
+    /// is indexed relative to the `SttsAtom`. Complexity of this function in O(N).
+    pub fn find_sample_for_timestamp(&self, ts: u64) -> Option<u32> {
+        let mut ts_accum = 0;
+        let mut sample_num = 0;
+
+        for entry in &self.entries {
+            let delta = u64::from(entry.sample_delta) * u64::from(entry.sample_count);
+
+            if ts_accum + delta > ts {
+                sample_num += ((ts - ts_accum) / u64::from(entry.sample_delta)) as u32;
+                return Some(sample_num);
+            }
+
+            ts_accum += delta;
+            sample_num += entry.sample_count;
+        }
+
+        None
+    }
+}
+
+impl Atom for SttsAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        let entry_count = reader.read_be_u32()?;
+
+        let mut total_duration = 0;
+
+        // TODO: Limit table length.
+        let mut entries = Vec::with_capacity(entry_count as usize);
+
+        for _ in 0..entry_count {
+            let sample_count = reader.read_be_u32()?;
+            let sample_delta = reader.read_be_u32()?;
+
+            total_duration += u64::from(sample_count) * u64::from(sample_delta);
+
+            entries.push(SampleDurationEntry { sample_count, sample_delta });
+        }
+
+        Ok(SttsAtom { header, entries, total_duration })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/tfhd.rs

@@ -0,0 +1,84 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+/// Track fragment header atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct TfhdAtom {
+    /// Atom header.
+    header: AtomHeader,
+    pub track_id: u32,
+    pub base_data_offset: Option<u64>,
+    pub sample_desc_idx: Option<u32>,
+    pub default_sample_duration: Option<u32>,
+    pub default_sample_size: Option<u32>,
+    pub default_sample_flags: Option<u32>,
+    /// If true, there are no samples for this time duration.
+    pub duration_is_empty: bool,
+    /// If true, the base data offset for this track is the first byte of the parent containing moof
+    /// atom.
+    pub default_base_is_moof: bool,
+}
+
+impl Atom for TfhdAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, flags) = AtomHeader::read_extra(reader)?;
+
+        let track_id = reader.read_be_u32()?;
+
+        let base_data_offset = match flags & 0x1 {
+            0 => None,
+            _ => Some(reader.read_be_u64()?),
+        };
+
+        let sample_desc_idx = match flags & 0x2 {
+            0 => None,
+            _ => Some(reader.read_be_u32()?),
+        };
+
+        let default_sample_duration = match flags & 0x8 {
+            0 => None,
+            _ => Some(reader.read_be_u32()?),
+        };
+
+        let default_sample_size = match flags & 0x10 {
+            0 => None,
+            _ => Some(reader.read_be_u32()?),
+        };
+
+        let default_sample_flags = match flags & 0x20 {
+            0 => None,
+            _ => Some(reader.read_be_u32()?),
+        };
+
+        let duration_is_empty = (flags & 0x1_0000) != 0;
+
+        // The default-base-is-moof flag is ignored if the base-data-offset flag is set.
+        let default_base_is_moof = (flags & 0x1 == 0) && (flags & 0x2_0000 != 0);
+
+        Ok(TfhdAtom {
+            header,
+            track_id,
+            base_data_offset,
+            sample_desc_idx,
+            default_sample_duration,
+            default_sample_size,
+            default_sample_flags,
+            duration_is_empty,
+            default_base_is_moof,
+        })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/tkhd.rs

@@ -0,0 +1,89 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+use crate::fp::FpU8;
+
+/// Track header atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct TkhdAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Track header flags.
+    pub flags: u32,
+    /// Creation time.
+    pub ctime: u64,
+    /// Modification time.
+    pub mtime: u64,
+    /// Track identifier.
+    pub id: u32,
+    /// Track duration in the timescale units specified in the movie header. This value is equal to
+    /// the sum of the durations of all the track's edits.
+    pub duration: u64,
+    /// Layer.
+    pub layer: u16,
+    /// Grouping identifier.
+    pub alternate_group: u16,
+    /// Preferred volume for track playback.
+    pub volume: FpU8,
+}
+
+impl Atom for TkhdAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (version, flags) = AtomHeader::read_extra(reader)?;
+
+        let mut tkhd = TkhdAtom {
+            header,
+            flags,
+            ctime: 0,
+            mtime: 0,
+            id: 0,
+            duration: 0,
+            layer: 0,
+            alternate_group: 0,
+            volume: Default::default(),
+        };
+
+        // Version 0 uses 32-bit time values, verion 1 used 64-bit values.
+        match version {
+            0 => {
+                tkhd.ctime = u64::from(reader.read_be_u32()?);
+                tkhd.mtime = u64::from(reader.read_be_u32()?);
+                tkhd.id = reader.read_be_u32()?;
+                let _ = reader.read_be_u32()?; // Reserved
+                tkhd.duration = u64::from(reader.read_be_u32()?);
+            }
+            1 => {
+                tkhd.ctime = reader.read_be_u64()?;
+                tkhd.mtime = reader.read_be_u64()?;
+                tkhd.id = reader.read_be_u32()?;
+                let _ = reader.read_be_u32()?; // Reserved
+                tkhd.duration = reader.read_be_u64()?;
+            }
+            _ => return decode_error("isomp4: invalid tkhd version"),
+        }
+
+        // Reserved
+        let _ = reader.read_be_u64()?;
+
+        tkhd.layer = reader.read_be_u16()?;
+        tkhd.alternate_group = reader.read_be_u16()?;
+        tkhd.volume = FpU8::parse_raw(reader.read_be_u16()?);
+
+        // The remainder of the header is only useful for video tracks.
+
+        Ok(tkhd)
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/traf.rs

@@ -0,0 +1,64 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType, TfhdAtom, TrunAtom};
+
+/// Track fragment atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct TrafAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Track fragment header.
+    pub tfhd: TfhdAtom,
+    /// Track fragment sample runs.
+    pub truns: Vec<TrunAtom>,
+    /// The total number of samples in this track fragment.
+    pub total_sample_count: u32,
+}
+
+impl Atom for TrafAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut tfhd = None;
+        let mut truns = Vec::new();
+
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut total_sample_count = 0;
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::TrackFragmentHeader => {
+                    tfhd = Some(iter.read_atom::<TfhdAtom>()?);
+                }
+                AtomType::TrackFragmentRun => {
+                    let trun = iter.read_atom::<TrunAtom>()?;
+
+                    // Increment the total sample count.
+                    total_sample_count += trun.sample_count;
+
+                    truns.push(trun);
+                }
+                _ => (),
+            }
+        }
+
+        // Tfhd is mandatory.
+        if tfhd.is_none() {
+            return decode_error("isomp4: missing tfhd atom");
+        }
+
+        Ok(TrafAtom { header, tfhd: tfhd.unwrap(), truns, total_sample_count })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/trak.rs

@@ -0,0 +1,64 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType, EdtsAtom, MdiaAtom, TkhdAtom};
+
+/// Track atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct TrakAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Track header atom.
+    pub tkhd: TkhdAtom,
+    /// Optional, edit list atom.
+    pub edts: Option<EdtsAtom>,
+    /// Media atom.
+    pub mdia: MdiaAtom,
+}
+
+impl Atom for TrakAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut tkhd = None;
+        let mut edts = None;
+        let mut mdia = None;
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::TrackHeader => {
+                    tkhd = Some(iter.read_atom::<TkhdAtom>()?);
+                }
+                AtomType::Edit => {
+                    edts = Some(iter.read_atom::<EdtsAtom>()?);
+                }
+                AtomType::Media => {
+                    mdia = Some(iter.read_atom::<MdiaAtom>()?);
+                }
+                _ => (),
+            }
+        }
+
+        if tkhd.is_none() {
+            return decode_error("isomp4: missing tkhd atom");
+        }
+
+        if mdia.is_none() {
+            return decode_error("isomp4: missing mdia atom");
+        }
+
+        Ok(TrakAtom { header, tkhd: tkhd.unwrap(), edts, mdia: mdia.unwrap() })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/trex.rs

@@ -0,0 +1,48 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader};
+
+/// Track extends atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct TrexAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Track this atom describes.
+    pub track_id: u32,
+    /// Default sample description index.
+    pub default_sample_desc_idx: u32,
+    /// Default sample duration.
+    pub default_sample_duration: u32,
+    /// Default sample size.
+    pub default_sample_size: u32,
+    /// Default sample flags.
+    pub default_sample_flags: u32,
+}
+
+impl Atom for TrexAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, _) = AtomHeader::read_extra(reader)?;
+
+        Ok(TrexAtom {
+            header,
+            track_id: reader.read_be_u32()?,
+            default_sample_desc_idx: reader.read_be_u32()?,
+            default_sample_duration: reader.read_be_u32()?,
+            default_sample_size: reader.read_be_u32()?,
+            default_sample_flags: reader.read_be_u32()?,
+        })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/trun.rs

@@ -0,0 +1,321 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::{decode_error, Result};
+use symphonia_core::io::ReadBytes;
+use symphonia_core::util::bits;
+
+use crate::atoms::{Atom, AtomHeader};
+
+/// Track fragment run atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct TrunAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Extended header flags.
+    flags: u32,
+    /// Data offset of this run.
+    pub data_offset: Option<i32>,
+    /// Number of samples in this run.
+    pub sample_count: u32,
+    /// Sample flags for the first sample only.
+    pub first_sample_flags: Option<u32>,
+    /// Sample duration for each sample in this run.
+    pub sample_duration: Vec<u32>,
+    /// Sample size for each sample in this run.
+    pub sample_size: Vec<u32>,
+    /// Sample flags for each sample in this run.
+    pub sample_flags: Vec<u32>,
+    /// The total size of all samples in this run. 0 if the sample size flag is not set.
+    total_sample_size: u64,
+    /// The total duration of all samples in this run. 0 if the sample duration flag is not set.
+    total_sample_duration: u64,
+}
+
+impl TrunAtom {
+    // Track fragment run atom flags.
+    const DATA_OFFSET_PRESENT: u32 = 0x1;
+    const FIRST_SAMPLE_FLAGS_PRESENT: u32 = 0x4;
+    const SAMPLE_DURATION_PRESENT: u32 = 0x100;
+    const SAMPLE_SIZE_PRESENT: u32 = 0x200;
+    const SAMPLE_FLAGS_PRESENT: u32 = 0x400;
+    const SAMPLE_COMPOSITION_TIME_OFFSETS_PRESENT: u32 = 0x800;
+
+    /// Indicates if sample durations are provided.
+    pub fn is_sample_duration_present(&self) -> bool {
+        self.flags & TrunAtom::SAMPLE_DURATION_PRESENT != 0
+    }
+
+    // Indicates if the duration of the first sample is provided.
+    pub fn is_first_sample_duration_present(&self) -> bool {
+        match self.first_sample_flags {
+            Some(flags) => flags & TrunAtom::FIRST_SAMPLE_FLAGS_PRESENT != 0,
+            None => false,
+        }
+    }
+
+    /// Indicates if sample sizes are provided.
+    pub fn is_sample_size_present(&self) -> bool {
+        self.flags & TrunAtom::SAMPLE_SIZE_PRESENT != 0
+    }
+
+    /// Indicates if the size for the first sample is provided.
+    pub fn is_first_sample_size_present(&self) -> bool {
+        match self.first_sample_flags {
+            Some(flags) => flags & TrunAtom::SAMPLE_SIZE_PRESENT != 0,
+            None => false,
+        }
+    }
+
+    /// Indicates if sample flags are provided.
+    #[allow(dead_code)]
+    pub fn are_sample_flags_present(&self) -> bool {
+        self.flags & TrunAtom::SAMPLE_FLAGS_PRESENT != 0
+    }
+
+    /// Indicates if sample composition time offsets are provided.
+    #[allow(dead_code)]
+    pub fn are_sample_composition_time_offsets_present(&self) -> bool {
+        self.flags & TrunAtom::SAMPLE_COMPOSITION_TIME_OFFSETS_PRESENT != 0
+    }
+
+    /// Gets the total duration of all samples.
+    pub fn total_duration(&self, default_dur: u32) -> u64 {
+        if self.is_sample_duration_present() {
+            self.total_sample_duration
+        }
+        else {
+            // The duration of all samples in the track fragment are not explictly known.
+            if self.sample_count > 0 && self.is_first_sample_duration_present() {
+                // The first sample has an explictly recorded duration.
+                u64::from(self.sample_duration[0])
+                    + u64::from(self.sample_count - 1) * u64::from(default_dur)
+            }
+            else {
+                // All samples have the default duration.
+                u64::from(self.sample_count) * u64::from(default_dur)
+            }
+        }
+    }
+
+    /// Gets the total size of all samples.
+    pub fn total_size(&self, default_size: u32) -> u64 {
+        if self.is_sample_size_present() {
+            self.total_sample_size
+        }
+        else if self.sample_count > 0 && self.is_first_sample_size_present() {
+            u64::from(self.sample_size[0])
+                + u64::from(self.sample_count - 1) * u64::from(default_size)
+        }
+        else {
+            u64::from(self.sample_count) * u64::from(default_size)
+        }
+    }
+
+    /// Get the timestamp and duration of a sample. The desired sample is specified by the
+    /// trun-relative sample number, `sample_num_rel`.
+    pub fn sample_timing(&self, sample_num_rel: u32, default_dur: u32) -> (u64, u32) {
+        debug_assert!(sample_num_rel < self.sample_count);
+
+        if self.is_sample_duration_present() {
+            // All sample durations are unique.
+            let ts = if sample_num_rel > 0 {
+                self.sample_duration[..sample_num_rel as usize]
+                    .iter()
+                    .map(|&s| u64::from(s))
+                    .sum::<u64>()
+            }
+            else {
+                0
+            };
+
+            let dur = self.sample_duration[sample_num_rel as usize];
+
+            (ts, dur)
+        }
+        else {
+            // The duration of all samples in the track fragment are not unique.
+            let ts = if sample_num_rel > 0 && self.is_first_sample_duration_present() {
+                // The first sample has a unique duration.
+                u64::from(self.sample_duration[0])
+                    + u64::from(sample_num_rel - 1) * u64::from(default_dur)
+            }
+            else {
+                // Zero or more samples with identical durations.
+                u64::from(sample_num_rel) * u64::from(default_dur)
+            };
+
+            (ts, default_dur)
+        }
+    }
+
+    /// Get the size of a sample. The desired sample is specified by the trun-relative sample
+    /// number, `sample_num_rel`.
+    pub fn sample_size(&self, sample_num_rel: u32, default_size: u32) -> u32 {
+        debug_assert!(sample_num_rel < self.sample_count);
+
+        if self.is_sample_size_present() {
+            self.sample_size[sample_num_rel as usize]
+        }
+        else if sample_num_rel == 0 && self.is_first_sample_size_present() {
+            self.sample_size[0]
+        }
+        else {
+            default_size
+        }
+    }
+
+    /// Get the byte offset and size of a sample. The desired sample is specified by the
+    /// trun-relative sample number, `sample_num_rel`.
+    pub fn sample_offset(&self, sample_num_rel: u32, default_size: u32) -> (u64, u32) {
+        debug_assert!(sample_num_rel < self.sample_count);
+
+        if self.is_sample_size_present() {
+            // All sample sizes are unique.
+            let offset = if sample_num_rel > 0 {
+                self.sample_size[..sample_num_rel as usize]
+                    .iter()
+                    .map(|&s| u64::from(s))
+                    .sum::<u64>()
+            }
+            else {
+                0
+            };
+
+            (offset, self.sample_size[sample_num_rel as usize])
+        }
+        else {
+            // The size of all samples in the track are not unique.
+            let offset = if sample_num_rel > 0 && self.is_first_sample_size_present() {
+                // The first sample has a unique size.
+                u64::from(self.sample_size[0])
+                    + u64::from(sample_num_rel - 1) * u64::from(default_size)
+            }
+            else {
+                // Zero or more identically sized samples.
+                u64::from(sample_num_rel) * u64::from(default_size)
+            };
+
+            (offset, default_size)
+        }
+    }
+
+    /// Get the sample number (relative to the trun) of the sample that contains timestamp `ts`.
+    pub fn ts_sample(&self, ts_rel: u64, default_dur: u32) -> u32 {
+        let mut sample_num = 0;
+        let mut ts_delta = ts_rel;
+
+        if self.is_sample_duration_present() {
+            // If the sample durations are present, then each sample duration is independently
+            // stored. Sum sample durations until the delta is reached.
+            for &dur in &self.sample_duration {
+                if u64::from(dur) > ts_delta {
+                    break;
+                }
+
+                ts_delta -= u64::from(dur);
+                sample_num += 1;
+            }
+        }
+        else {
+            if self.sample_count > 0 && self.is_first_sample_duration_present() {
+                // The first sample duration is unique.
+                let first_sample_dur = u64::from(self.sample_duration[0]);
+
+                if ts_delta >= first_sample_dur {
+                    ts_delta -= first_sample_dur;
+                    sample_num += 1;
+                }
+                else {
+                    ts_delta -= ts_delta;
+                }
+            }
+
+            sample_num += ts_delta.checked_div(u64::from(default_dur)).unwrap_or(0) as u32;
+        }
+
+        sample_num
+    }
+}
+
+impl Atom for TrunAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let (_, flags) = AtomHeader::read_extra(reader)?;
+
+        let sample_count = reader.read_be_u32()?;
+
+        let data_offset = match flags & TrunAtom::DATA_OFFSET_PRESENT {
+            0 => None,
+            _ => Some(bits::sign_extend_leq32_to_i32(reader.read_be_u32()?, 32)),
+        };
+
+        let first_sample_flags = match flags & TrunAtom::FIRST_SAMPLE_FLAGS_PRESENT {
+            0 => None,
+            _ => Some(reader.read_be_u32()?),
+        };
+
+        // If the first-sample-flags-present flag is set, then the sample-flags-present flag should
+        // not be set. The samples after the first shall use the default sample flags defined in the
+        // tfhd or mvex atoms.
+        if first_sample_flags.is_some() && (flags & TrunAtom::SAMPLE_FLAGS_PRESENT != 0) {
+            return decode_error(
+                "isomp4: sample-flag-present and first-sample-flags-present flags are set",
+            );
+        }
+
+        let mut sample_duration = Vec::new();
+        let mut sample_size = Vec::new();
+        let mut sample_flags = Vec::new();
+
+        let mut total_sample_size = 0;
+        let mut total_sample_duration = 0;
+
+        // TODO: Apply a limit.
+        for _ in 0..sample_count {
+            if (flags & TrunAtom::SAMPLE_DURATION_PRESENT) != 0 {
+                let duration = reader.read_be_u32()?;
+                total_sample_duration += u64::from(duration);
+                sample_duration.push(duration);
+            }
+
+            if (flags & TrunAtom::SAMPLE_SIZE_PRESENT) != 0 {
+                let size = reader.read_be_u32()?;
+                total_sample_size += u64::from(size);
+                sample_size.push(size);
+            }
+
+            if (flags & TrunAtom::SAMPLE_FLAGS_PRESENT) != 0 {
+                sample_flags.push(reader.read_be_u32()?);
+            }
+
+            // Ignoring composition time for now since it's a video thing...
+            if (flags & TrunAtom::SAMPLE_COMPOSITION_TIME_OFFSETS_PRESENT) != 0 {
+                // For version 0, this is a u32.
+                // For version 1, this is a i32.
+                let _ = reader.read_be_u32()?;
+            }
+        }
+
+        Ok(TrunAtom {
+            header,
+            flags,
+            data_offset,
+            sample_count,
+            first_sample_flags,
+            sample_duration,
+            sample_size,
+            sample_flags,
+            total_sample_size,
+            total_sample_duration,
+        })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/udta.rs

@@ -0,0 +1,53 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+use symphonia_core::meta::MetadataRevision;
+
+use crate::atoms::{Atom, AtomHeader, AtomIterator, AtomType, MetaAtom};
+
+/// User data atom.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct UdtaAtom {
+    /// Atom header.
+    header: AtomHeader,
+    /// Metadata atom.
+    pub meta: Option<MetaAtom>,
+}
+
+impl UdtaAtom {
+    /// If metadata was read, consumes the metadata and returns it.
+    pub fn take_metadata(&mut self) -> Option<MetadataRevision> {
+        self.meta.as_mut().and_then(|meta| meta.take_metadata())
+    }
+}
+
+impl Atom for UdtaAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    #[allow(clippy::single_match)]
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut meta = None;
+
+        while let Some(header) = iter.next()? {
+            match header.atype {
+                AtomType::Meta => {
+                    meta = Some(iter.read_atom::<MetaAtom>()?);
+                }
+                _ => (),
+            }
+        }
+
+        Ok(UdtaAtom { header, meta })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/atoms/wave.rs

@@ -0,0 +1,41 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::errors::Result;
+use symphonia_core::io::ReadBytes;
+
+use crate::atoms::{Atom, AtomHeader, EsdsAtom};
+
+use super::{AtomIterator, AtomType};
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct WaveAtom {
+    /// Atom header.
+    header: AtomHeader,
+    pub esds: Option<EsdsAtom>,
+}
+
+impl Atom for WaveAtom {
+    fn header(&self) -> AtomHeader {
+        self.header
+    }
+
+    fn read<B: ReadBytes>(reader: &mut B, header: AtomHeader) -> Result<Self> {
+        let mut iter = AtomIterator::new(reader, header);
+
+        let mut esds = None;
+
+        while let Some(header) = iter.next()? {
+            if header.atype == AtomType::Esds {
+                esds = Some(iter.read_atom::<EsdsAtom>()?);
+            }
+        }
+
+        Ok(WaveAtom { header, esds })
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/demuxer.rs

@@ -0,0 +1,606 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use symphonia_core::{errors::end_of_stream_error, support_format};
+
+use symphonia_core::codecs::CodecParameters;
+use symphonia_core::errors::{
+    decode_error, seek_error, unsupported_error, Error, Result, SeekErrorKind,
+};
+use symphonia_core::formats::prelude::*;
+use symphonia_core::io::{MediaSource, MediaSourceStream, ReadBytes, SeekBuffered};
+use symphonia_core::meta::{Metadata, MetadataLog};
+use symphonia_core::probe::{Descriptor, Instantiate, QueryDescriptor};
+use symphonia_core::units::Time;
+
+use std::io::{Seek, SeekFrom};
+use std::sync::Arc;
+
+use crate::atoms::{AtomIterator, AtomType};
+use crate::atoms::{FtypAtom, MetaAtom, MoofAtom, MoovAtom, MvexAtom, SidxAtom, TrakAtom};
+use crate::stream::*;
+
+use log::{debug, info, trace, warn};
+
+pub struct TrackState {
+    codec_params: CodecParameters,
+    /// The track number.
+    track_num: usize,
+    /// The current segment.
+    cur_seg: usize,
+    /// The current sample index relative to the track.
+    next_sample: u32,
+    /// The current sample byte position relative to the start of the track.
+    next_sample_pos: u64,
+}
+
+impl TrackState {
+    #[allow(clippy::single_match)]
+    pub fn new(track_num: usize, trak: &TrakAtom) -> Self {
+        let mut codec_params = CodecParameters::new();
+
+        codec_params
+            .with_time_base(TimeBase::new(1, trak.mdia.mdhd.timescale))
+            .with_n_frames(trak.mdia.mdhd.duration);
+
+        // Fill the codec parameters using the sample description atom.
+        trak.mdia.minf.stbl.stsd.fill_codec_params(&mut codec_params);
+
+        Self { codec_params, track_num, cur_seg: 0, next_sample: 0, next_sample_pos: 0 }
+    }
+
+    pub fn codec_params(&self) -> CodecParameters {
+        self.codec_params.clone()
+    }
+}
+
+/// Information regarding the next sample.
+#[derive(Debug)]
+struct NextSampleInfo {
+    /// The track number of the next sample.
+    track_num: usize,
+    /// The timestamp of the next sample.
+    ts: u64,
+    /// The timestamp expressed in seconds.
+    time: Time,
+    /// The duration of the next sample.
+    dur: u32,
+    /// The segment containing the next sample.
+    seg_idx: usize,
+}
+
+/// Information regarding a sample.
+#[derive(Debug)]
+struct SampleDataInfo {
+    /// The position of the sample in the track.
+    pos: u64,
+    /// The length of the sample.
+    len: u32,
+}
+
+/// ISO Base Media File Format (MP4, M4A, MOV, etc.) demultiplexer.
+///
+/// `IsoMp4Reader` implements a demuxer for the ISO Base Media File Format.
+pub struct IsoMp4Reader {
+    iter: AtomIterator<MediaSourceStream>,
+    tracks: Vec<Track>,
+    cues: Vec<Cue>,
+    metadata: MetadataLog,
+    /// Segments of the movie. Sorted in ascending order by sequence number.
+    segs: Vec<Box<dyn StreamSegment>>,
+    /// State tracker for each track.
+    track_states: Vec<TrackState>,
+    /// Optional, movie extends atom used for fragmented streams.
+    mvex: Option<Arc<MvexAtom>>,
+}
+
+impl IsoMp4Reader {
+    /// Idempotently gets information regarding the next sample of the media stream. This function
+    /// selects the next sample with the lowest timestamp of all tracks.
+    fn next_sample_info(&self) -> Result<Option<NextSampleInfo>> {
+        let mut earliest = None;
+
+        // TODO: Consider returning samples based on lowest byte position in the track instead of
+        // timestamp. This may be important if video tracks are ever decoded (i.e., DTS vs. PTS).
+
+        for (state, track) in self.track_states.iter().zip(&self.tracks) {
+            // Get the timebase of the track used to calculate the presentation time.
+            let tb = track.codec_params.time_base.unwrap();
+
+            // Get the next timestamp for the next sample of the current track. The next sample may
+            // be in a future segment.
+            for (seg_idx_delta, seg) in self.segs[state.cur_seg..].iter().enumerate() {
+                // Try to get the timestamp for the next sample of the track from the segment.
+                if let Some(timing) = seg.sample_timing(state.track_num, state.next_sample)? {
+                    // Calculate the presentation time using the timestamp.
+                    let sample_time = tb.calc_time(timing.ts);
+
+                    // Compare the presentation time of the sample from this track to other tracks,
+                    // and select the track with the earliest presentation time.
+                    match earliest {
+                        Some(NextSampleInfo { track_num: _, ts: _, time, dur: _, seg_idx: _ })
+                            if time <= sample_time =>
+                        {
+                            // Earliest is less than or equal to the track's next sample
+                            // presentation time. No need to update earliest.
+                        }
+                        _ => {
+                            // Earliest was either None, or greater than the track's next sample
+                            // presentation time. Update earliest.
+                            earliest = Some(NextSampleInfo {
+                                track_num: state.track_num,
+                                ts: timing.ts,
+                                time: sample_time,
+                                dur: timing.dur,
+                                seg_idx: seg_idx_delta + state.cur_seg,
+                            });
+                        }
+                    }
+
+                    // Either the next sample of the track had the earliest presentation time seen
+                    // thus far, or it was greater than those from other tracks, but there is no
+                    // reason to check samples in future segments.
+                    break;
+                }
+            }
+        }
+
+        Ok(earliest)
+    }
+
+    fn consume_next_sample(&mut self, info: &NextSampleInfo) -> Result<Option<SampleDataInfo>> {
+        // Get the track state.
+        let track = &mut self.track_states[info.track_num];
+
+        // Get the segment associated with the sample.
+        let seg = &self.segs[info.seg_idx];
+
+        // Get the sample data descriptor.
+        let sample_data_desc = seg.sample_data(track.track_num, track.next_sample, false)?;
+
+        // The sample base position in the sample data descriptor remains constant if the sample
+        // followed immediately after the previous sample. In this case, the track state's
+        // next_sample_pos is the position of the current sample. If the base position has jumped,
+        // then the base position is the position of current the sample.
+        let pos = if sample_data_desc.base_pos > track.next_sample_pos {
+            sample_data_desc.base_pos
+        }
+        else {
+            track.next_sample_pos
+        };
+
+        // Advance the track's current segment to the next sample's segment.
+        track.cur_seg = info.seg_idx;
+
+        // Advance the track's next sample number and position.
+        track.next_sample += 1;
+        track.next_sample_pos = pos + u64::from(sample_data_desc.size);
+
+        Ok(Some(SampleDataInfo { pos, len: sample_data_desc.size }))
+    }
+
+    fn try_read_more_segments(&mut self) -> Result<()> {
+        // Continue iterating over atoms until a segment (a moof + mdat atom pair) is found. All
+        // other atoms will be ignored.
+        while let Some(header) = self.iter.next_no_consume()? {
+            match header.atype {
+                AtomType::MediaData => {
+                    // Consume the atom from the iterator so that on the next iteration a new atom
+                    // will be read.
+                    self.iter.consume_atom();
+
+                    return Ok(());
+                }
+                AtomType::MovieFragment => {
+                    let moof = self.iter.read_atom::<MoofAtom>()?;
+
+                    // A moof segment can only be created if the mvex atom is present.
+                    if let Some(mvex) = &self.mvex {
+                        // Get the last segment. Note, there will always be one segment because the
+                        // moov atom is converted into a segment when the reader is instantiated.
+                        let last_seg = self.segs.last().unwrap();
+
+                        // Create a new segment for the moof atom.
+                        let seg = MoofSegment::new(moof, mvex.clone(), last_seg.as_ref());
+
+                        // Segments should have a monotonic sequence number.
+                        if seg.sequence_num() <= last_seg.sequence_num() {
+                            warn!("moof fragment has a non-monotonic sequence number.");
+                        }
+
+                        // Push the segment.
+                        self.segs.push(Box::new(seg));
+                    }
+                    else {
+                        // TODO: This is a fatal error.
+                        return decode_error("isomp4: moof atom present without mvex atom");
+                    }
+                }
+                _ => {
+                    trace!("skipping atom: {:?}.", header.atype);
+                    self.iter.consume_atom();
+                }
+            }
+        }
+
+        // If no atoms were returned above, then the end-of-stream has been reached.
+        end_of_stream_error()
+    }
+
+    fn seek_track_by_time(&mut self, track_num: usize, time: Time) -> Result<SeekedTo> {
+        // Convert time to timestamp for the track.
+        if let Some(track) = self.tracks.get(track_num) {
+            let tb = track.codec_params.time_base.unwrap();
+            self.seek_track_by_ts(track_num, tb.calc_timestamp(time))
+        }
+        else {
+            seek_error(SeekErrorKind::Unseekable)
+        }
+    }
+
+    fn seek_track_by_ts(&mut self, track_num: usize, ts: u64) -> Result<SeekedTo> {
+        debug!("seeking track={} to frame_ts={}", track_num, ts);
+
+        struct SeekLocation {
+            seg_idx: usize,
+            sample_num: u32,
+        }
+
+        let mut seek_loc = None;
+        let mut seg_skip = 0;
+
+        loop {
+            // Iterate over all segments and attempt to find the segment and sample number that
+            // contains the desired timestamp. Skip segments already examined.
+            for (seg_idx, seg) in self.segs.iter().enumerate().skip(seg_skip) {
+                if let Some(sample_num) = seg.ts_sample(track_num, ts)? {
+                    seek_loc = Some(SeekLocation { seg_idx, sample_num });
+                    break;
+                }
+
+                // Mark the segment as examined.
+                seg_skip = seg_idx + 1;
+            }
+
+            // If a seek location is found, break.
+            if seek_loc.is_some() {
+                break;
+            }
+
+            // Otherwise, try to read more segments from the stream.
+            self.try_read_more_segments()?;
+        }
+
+        if let Some(seek_loc) = seek_loc {
+            let seg = &self.segs[seek_loc.seg_idx];
+
+            // Get the sample information.
+            let data_desc = seg.sample_data(track_num, seek_loc.sample_num, true)?;
+
+            // Update the track's next sample information to point to the seeked sample.
+            let track = &mut self.track_states[track_num];
+
+            track.cur_seg = seek_loc.seg_idx;
+            track.next_sample = seek_loc.sample_num;
+            track.next_sample_pos = data_desc.base_pos + data_desc.offset.unwrap();
+
+            // Get the actual timestamp for this sample.
+            let timing = seg.sample_timing(track_num, seek_loc.sample_num)?.unwrap();
+
+            debug!(
+                "seeked track={} to packet_ts={} (delta={})",
+                track_num,
+                timing.ts,
+                timing.ts as i64 - ts as i64
+            );
+
+            Ok(SeekedTo { track_id: track_num as u32, required_ts: ts, actual_ts: timing.ts })
+        }
+        else {
+            // Timestamp was not found.
+            seek_error(SeekErrorKind::OutOfRange)
+        }
+    }
+}
+
+impl QueryDescriptor for IsoMp4Reader {
+    fn query() -> &'static [Descriptor] {
+        &[support_format!(
+            "isomp4",
+            "ISO Base Media File Format",
+            &["mp4", "m4a", "m4p", "m4b", "m4r", "m4v", "mov"],
+            &["video/mp4", "audio/mp4"],
+            &[b"ftyp"] // Top-level atoms
+        )]
+    }
+
+    fn score(_context: &[u8]) -> u8 {
+        255
+    }
+}
+
+impl FormatReader for IsoMp4Reader {
+    fn try_new(mut mss: MediaSourceStream, _options: &FormatOptions) -> Result<Self> {
+        // To get to beginning of the atom.
+        mss.seek_buffered_rel(-4);
+
+        let is_seekable = mss.is_seekable();
+
+        let mut ftyp = None;
+        let mut moov = None;
+        let mut sidx = None;
+
+        // Get the total length of the stream, if possible.
+        let total_len = if is_seekable {
+            let pos = mss.pos();
+            let len = mss.byte_len().ok_or(Error::SeekError(SeekErrorKind::Unseekable))?;
+            mss.seek(SeekFrom::Start(pos))?;
+            info!("stream is seekable with len={} bytes.", len);
+            Some(len)
+        }
+        else {
+            None
+        };
+
+        let mut metadata = MetadataLog::default();
+
+        // Parse all atoms if the stream is seekable, otherwise parse all atoms up-to the mdat atom.
+        let mut iter = AtomIterator::new_root(mss, total_len);
+
+        while let Some(header) = iter.next()? {
+            // Top-level atoms.
+            match header.atype {
+                AtomType::FileType => {
+                    ftyp = Some(iter.read_atom::<FtypAtom>()?);
+                }
+                AtomType::Movie => {
+                    moov = Some(iter.read_atom::<MoovAtom>()?);
+                }
+                AtomType::SegmentIndex => {
+                    // If the stream is not seekable, then it can only be assumed that the first
+                    // segment index atom is indeed the first segment index because the format
+                    // reader cannot practically skip past this point.
+                    if !is_seekable {
+                        sidx = Some(iter.read_atom::<SidxAtom>()?);
+                        break;
+                    }
+                    else {
+                        // If the stream is seekable, examine all segment indexes and select the
+                        // index with the earliest presentation timestamp to be the first.
+                        let new_sidx = iter.read_atom::<SidxAtom>()?;
+
+                        let is_earlier = match &sidx {
+                            Some(sidx) => new_sidx.earliest_pts < sidx.earliest_pts,
+                            _ => true,
+                        };
+
+                        if is_earlier {
+                            sidx = Some(new_sidx);
+                        }
+                    }
+                }
+                AtomType::MediaData | AtomType::MovieFragment => {
+                    // The mdat atom contains the codec bitstream data. For segmented streams, a
+                    // moof + mdat pair is required for playback. If the source is unseekable then
+                    // the format reader cannot skip past these atoms without dropping samples.
+                    if !is_seekable {
+                        // If the moov atom hasn't been seen before the moof and/or mdat atom, and
+                        // the stream is not seekable, then the mp4 is not streamable.
+                        if moov.is_none() || ftyp.is_none() {
+                            warn!("mp4 is not streamable.");
+                        }
+
+                        // The remainder of the stream will be read incrementally.
+                        break;
+                    }
+                }
+                AtomType::Meta => {
+                    // Read the metadata atom and append it to the log.
+                    let mut meta = iter.read_atom::<MetaAtom>()?;
+
+                    if let Some(rev) = meta.take_metadata() {
+                        metadata.push(rev);
+                    }
+                }
+                AtomType::Free => (),
+                AtomType::Skip => (),
+                _ => {
+                    info!("skipping top-level atom: {:?}.", header.atype);
+                }
+            }
+        }
+
+        if ftyp.is_none() {
+            return unsupported_error("isomp4: missing ftyp atom");
+        }
+
+        if moov.is_none() {
+            return unsupported_error("isomp4: missing moov atom");
+        }
+
+        // If the stream was seekable, then all atoms in the media source stream were scanned. Seek
+        // back to the first mdat atom for playback. If the stream is not seekable, then the atom
+        // iterator is currently positioned at the first mdat atom.
+        if is_seekable {
+            let mut mss = iter.into_inner();
+            mss.seek(SeekFrom::Start(0))?;
+
+            iter = AtomIterator::new_root(mss, total_len);
+
+            while let Some(header) = iter.next_no_consume()? {
+                match header.atype {
+                    AtomType::MediaData | AtomType::MovieFragment => break,
+                    _ => (),
+                }
+                iter.consume_atom();
+            }
+        }
+
+        let mut moov = moov.unwrap();
+
+        if moov.is_fragmented() {
+            // If a Segment Index (sidx) atom was found, add the segments contained within.
+            if sidx.is_some() {
+                info!("stream is segmented with a segment index.");
+            }
+            else {
+                info!("stream is segmented without a segment index.");
+            }
+        }
+
+        if let Some(rev) = moov.take_metadata() {
+            metadata.push(rev);
+        }
+
+        // Instantiate a TrackState for each track in the stream.
+        let track_states = moov
+            .traks
+            .iter()
+            .enumerate()
+            .map(|(t, trak)| TrackState::new(t, trak))
+            .collect::<Vec<TrackState>>();
+
+        // Instantiate a Tracks for all tracks above.
+        let tracks = track_states
+            .iter()
+            .map(|track| Track::new(track.track_num as u32, track.codec_params()))
+            .collect();
+
+        // A Movie Extends (mvex) atom is required to support segmented streams. If the mvex atom is
+        // present, wrap it in an Arc so it can be shared amongst all segments.
+        let mvex = moov.mvex.take().map(Arc::new);
+
+        // The number of tracks specified in the moov atom must match the number in the mvex atom.
+        if let Some(mvex) = &mvex {
+            if mvex.trexs.len() != moov.traks.len() {
+                return decode_error("isomp4: mvex and moov track number mismatch");
+            }
+        }
+
+        let segs: Vec<Box<dyn StreamSegment>> = vec![Box::new(MoovSegment::new(moov))];
+
+        Ok(IsoMp4Reader {
+            iter,
+            tracks,
+            cues: Default::default(),
+            metadata,
+            track_states,
+            segs,
+            mvex,
+        })
+    }
+
+    fn next_packet(&mut self) -> Result<Packet> {
+        // Get the index of the track with the next-nearest (minimum) timestamp.
+        let next_sample_info = loop {
+            // Using the current set of segments, try to get the next sample info.
+            if let Some(info) = self.next_sample_info()? {
+                break info;
+            }
+            else {
+                // No more segments. If the stream is unseekable, it may be the case that there are
+                // more segments coming. Iterate atoms until a new segment is found or the
+                // end-of-stream is reached.
+                self.try_read_more_segments()?;
+            }
+        };
+
+        // Get the position and length information of the next sample.
+        let sample_info = self.consume_next_sample(&next_sample_info)?.unwrap();
+
+        let reader = self.iter.inner_mut();
+
+        // Attempt a fast seek within the buffer cache.
+        if reader.seek_buffered(sample_info.pos) != sample_info.pos {
+            if reader.is_seekable() {
+                // Fallback to a slow seek if the stream is seekable.
+                reader.seek(SeekFrom::Start(sample_info.pos))?;
+            }
+            else if sample_info.pos > reader.pos() {
+                // The stream is not seekable but the desired seek position is ahead of the reader's
+                // current position, thus the seek can be emulated by ignoring the bytes up to the
+                // the desired seek position.
+                reader.ignore_bytes(sample_info.pos - reader.pos())?;
+            }
+            else {
+                // The stream is not seekable and the desired seek position falls outside the lower
+                // bound of the buffer cache. This sample cannot be read.
+                return decode_error("isomp4: packet out-of-bounds for a non-seekable stream");
+            }
+        }
+
+        Ok(Packet::new_from_boxed_slice(
+            next_sample_info.track_num as u32,
+            next_sample_info.ts,
+            u64::from(next_sample_info.dur),
+            reader.read_boxed_slice_exact(sample_info.len as usize)?,
+        ))
+    }
+
+    fn metadata(&mut self) -> Metadata<'_> {
+        self.metadata.metadata()
+    }
+
+    fn cues(&self) -> &[Cue] {
+        &self.cues
+    }
+
+    fn tracks(&self) -> &[Track] {
+        &self.tracks
+    }
+
+    fn seek(&mut self, _mode: SeekMode, to: SeekTo) -> Result<SeekedTo> {
+        if self.tracks.is_empty() {
+            return seek_error(SeekErrorKind::Unseekable);
+        }
+
+        match to {
+            SeekTo::TimeStamp { ts, track_id } => {
+                let selected_track_id = track_id as usize;
+
+                // The seek timestamp is in timebase units specific to the selected track. Get the
+                // selected track and use the timebase to convert the timestamp into time units so
+                // that the other tracks can be seeked.
+                if let Some(selected_track) = self.tracks().get(selected_track_id) {
+                    // Convert to time units.
+                    let time = selected_track.codec_params.time_base.unwrap().calc_time(ts);
+
+                    // Seek all tracks excluding the primary track to the desired time.
+                    for t in 0..self.track_states.len() {
+                        if t != selected_track_id {
+                            self.seek_track_by_time(t, time)?;
+                        }
+                    }
+
+                    // Seek the primary track and return the result.
+                    self.seek_track_by_ts(selected_track_id, ts)
+                }
+                else {
+                    seek_error(SeekErrorKind::Unseekable)
+                }
+            }
+            SeekTo::Time { time, track_id } => {
+                // Select the first track if a selected track was not provided.
+                let selected_track_id = track_id.unwrap_or(0) as usize;
+
+                // Seek all tracks excluding the selected track and discard the result.
+                for t in 0..self.track_states.len() {
+                    if t != selected_track_id {
+                        self.seek_track_by_time(t, time)?;
+                    }
+                }
+
+                // Seek the primary track and return the result.
+                self.seek_track_by_time(selected_track_id, time)
+            }
+        }
+    }
+
+    fn into_inner(self: Box<Self>) -> MediaSourceStream {
+        self.iter.into_inner()
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/fourcc.rs

@@ -0,0 +1,31 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use std::fmt;
+
+/// Four character codes for typical Ftyps (reference: http://ftyps.com/).
+#[derive(PartialEq, Eq, Clone, Copy)]
+#[repr(transparent)]
+pub struct FourCc {
+    val: [u8; 4],
+}
+
+impl FourCc {
+    /// Construct a new FourCC code from the given byte array.
+    pub fn new(val: [u8; 4]) -> Self {
+        Self { val }
+    }
+}
+
+impl fmt::Debug for FourCc {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match std::str::from_utf8(&self.val) {
+            Ok(name) => f.write_str(name),
+            _ => write!(f, "{:x?}", self.val),
+        }
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/fp.rs

@@ -0,0 +1,78 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+/// An unsigned 16.16-bit fixed point value.
+#[derive(Copy, Clone, Debug, Default)]
+pub struct FpU16(u32);
+
+impl FpU16 {
+    pub fn new(val: u16) -> Self {
+        Self(u32::from(val) << 16)
+    }
+
+    pub fn parse_raw(val: u32) -> Self {
+        Self(val)
+    }
+}
+
+impl From<FpU16> for f64 {
+    fn from(fp: FpU16) -> Self {
+        f64::from(fp.0) / f64::from(1u32 << 16)
+    }
+}
+
+/// An unsigned 8.8-bit fixed point value.
+#[derive(Copy, Clone, Debug, Default)]
+pub struct FpU8(u16);
+
+impl FpU8 {
+    pub fn new(val: u8) -> Self {
+        Self(u16::from(val) << 8)
+    }
+
+    pub fn parse_raw(val: u16) -> Self {
+        Self(val)
+    }
+}
+
+impl From<FpU8> for f64 {
+    fn from(fp: FpU8) -> Self {
+        f64::from(fp.0) / f64::from(1u16 << 8)
+    }
+}
+
+impl From<FpU8> for f32 {
+    fn from(fp: FpU8) -> Self {
+        f32::from(fp.0) / f32::from(1u16 << 8)
+    }
+}
+
+/// An unsigned 8.8-bit fixed point value.
+#[derive(Copy, Clone, Debug, Default)]
+pub struct FpI8(i16);
+
+impl FpI8 {
+    pub fn new(val: i8) -> Self {
+        Self(i16::from(val) * 0x100)
+    }
+
+    pub fn parse_raw(val: i16) -> Self {
+        Self(val)
+    }
+}
+
+impl From<FpI8> for f64 {
+    fn from(fp: FpI8) -> Self {
+        f64::from(fp.0) / f64::from(1u16 << 8)
+    }
+}
+
+impl From<FpI8> for f32 {
+    fn from(fp: FpI8) -> Self {
+        f32::from(fp.0) / f32::from(1u16 << 8)
+    }
+}

src-tauri/patches/symphonia-format-isomp4/src/lib.rs

@@ -0,0 +1,22 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+#![warn(rust_2018_idioms)]
+// The following lints are allowed in all Symphonia crates. Please see clippy.toml for their
+// justification.
+#![allow(clippy::comparison_chain)]
+#![allow(clippy::excessive_precision)]
+#![allow(clippy::identity_op)]
+#![allow(clippy::manual_range_contains)]
+
+mod atoms;
+mod demuxer;
+mod fourcc;
+mod fp;
+mod stream;
+
+pub use demuxer::IsoMp4Reader;

src-tauri/patches/symphonia-format-isomp4/src/stream.rs

@@ -0,0 +1,444 @@
+// Symphonia
+// Copyright (c) 2019-2022 The Project Symphonia Developers.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+use symphonia_core::errors::{decode_error, Error, Result};
+
+use crate::atoms::{stsz::SampleSize, Co64Atom, MoofAtom, MoovAtom, MvexAtom, StcoAtom, TrafAtom};
+
+use std::ops::Range;
+use std::sync::Arc;
+
+/// Sample data information.
+pub struct SampleDataDesc {
+    /// The starting byte position within the media data of the group of samples that contains the
+    /// sample described.
+    pub base_pos: u64,
+    /// The offset relative to the base position of the sample described.
+    pub offset: Option<u64>,
+    /// The size of the sample.
+    pub size: u32,
+}
+
+/// Timing information for one sample.
+pub struct SampleTiming {
+    /// The timestamp of the sample.
+    pub ts: u64,
+    /// The duration of the sample.
+    pub dur: u32,
+}
+
+pub trait StreamSegment: Send + Sync {
+    /// Gets the sequence number of this segment.
+    fn sequence_num(&self) -> u32;
+
+    /// Gets the first and last sample numbers for the track `track_num`.
+    fn track_sample_range(&self, track_num: usize) -> Range<u32>;
+
+    /// Gets the first and last sample timestamps for the track `track_num`.
+    fn track_ts_range(&self, track_num: usize) -> Range<u64>;
+
+    /// Get the timestamp and duration for the sample indicated by `sample_num` for the track
+    /// `track_num`.
+    fn sample_timing(&self, track_num: usize, sample_num: u32) -> Result<Option<SampleTiming>>;
+
+    /// Get the sample number of the sample containing the timestamp indicated by `ts` for track
+    // `track_num`.
+    fn ts_sample(&self, track_num: usize, ts: u64) -> Result<Option<u32>>;
+
+    /// Get the byte position of the group of samples containing the sample indicated by
+    /// `sample_num` for track `track_num`, and it's size.
+    ///
+    /// Optionally, the offset of the sample relative to the aforementioned byte position can be
+    /// returned.
+    fn sample_data(
+        &self,
+        track_num: usize,
+        sample_num: u32,
+        get_offset: bool,
+    ) -> Result<SampleDataDesc>;
+}
+
+/// Track-to-stream sequencing information.
+#[derive(Copy, Clone, Debug, Default)]
+struct SequenceInfo {
+    /// The sample number of the first sample of a track in a fragment.
+    first_sample: u32,
+    /// The timestamp of the first sample of a track in a fragment.
+    first_ts: u64,
+    /// The total duration of all samples of a track in a fragment.
+    total_sample_duration: u64,
+    /// The total sample count of a track in a fragment.
+    total_sample_count: u32,
+    /// If present in the moof segment, this is the index of the track fragment atom for the track
+    /// this sequence information is associated with.
+    traf_idx: Option<usize>,
+}
+
+pub struct MoofSegment {
+    moof: MoofAtom,
+    mvex: Arc<MvexAtom>,
+    seq: Vec<SequenceInfo>,
+}
+
+impl MoofSegment {
+    /// Instantiate a new segment from a `MoofAtom`.
+    pub fn new(moof: MoofAtom, mvex: Arc<MvexAtom>, prev: &dyn StreamSegment) -> MoofSegment {
+        let mut seq = Vec::with_capacity(mvex.trexs.len());
+
+        // Calculate the sequence information for each track, even if not present in the fragment.
+        for (track_num, trex) in mvex.trexs.iter().enumerate() {
+            let mut info = SequenceInfo {
+                first_sample: prev.track_sample_range(track_num).end,
+                first_ts: prev.track_ts_range(track_num).end,
+                ..Default::default()
+            };
+
+            // Find the track fragment for the track.
+            for (traf_idx, traf) in moof.trafs.iter().enumerate() {
+                if trex.track_id != traf.tfhd.track_id {
+                    continue;
+                }
+
+                // Calculate the total duration of all runs in the fragment for the track.
+                let default_dur =
+                    traf.tfhd.default_sample_duration.unwrap_or(trex.default_sample_duration);
+
+                for trun in traf.truns.iter() {
+                    info.total_sample_duration += trun.total_duration(default_dur);
+                }
+
+                info.total_sample_count = traf.total_sample_count;
+                info.traf_idx = Some(traf_idx);
+            }
+
+            seq.push(info);
+        }
+
+        MoofSegment { moof, mvex, seq }
+    }
+
+    /// Try to get the Track Fragment atom associated with the track identified by `track_num`.
+    fn try_get_traf(&self, track_num: usize) -> Option<&TrafAtom> {
+        debug_assert!(track_num < self.seq.len());
+        self.seq[track_num].traf_idx.map(|idx| &self.moof.trafs[idx])
+    }
+}
+
+impl StreamSegment for MoofSegment {
+    fn sequence_num(&self) -> u32 {
+        self.moof.mfhd.sequence_number
+    }
+
+    fn sample_timing(&self, track_num: usize, sample_num: u32) -> Result<Option<SampleTiming>> {
+        // Get the track fragment associated with track_num.
+        let traf = match self.try_get_traf(track_num) {
+            Some(traf) => traf,
+            None => return Ok(None),
+        };
+
+        let mut sample_num_rel = sample_num - self.seq[track_num].first_sample;
+        let mut trun_ts_offset = self.seq[track_num].first_ts;
+
+        let default_dur = traf
+            .tfhd
+            .default_sample_duration
+            .unwrap_or(self.mvex.trexs[track_num].default_sample_duration);
+
+        for trun in traf.truns.iter() {
+            // If the sample is contained within the this track run, get the timing of of the
+            // sample.
+            if sample_num_rel < trun.sample_count {
+                let (ts, dur) = trun.sample_timing(sample_num_rel, default_dur);
+                return Ok(Some(SampleTiming { ts: trun_ts_offset + ts, dur }));
+            }
+
+            let trun_dur = trun.total_duration(default_dur);
+
+            sample_num_rel -= trun.sample_count;
+            trun_ts_offset += trun_dur;
+        }
+
+        Ok(None)
+    }
+
+    fn ts_sample(&self, track_num: usize, ts: u64) -> Result<Option<u32>> {
+        // Get the track fragment associated with track_num.
+        let traf = match self.try_get_traf(track_num) {
+            Some(traf) => traf,
+            None => return Ok(None),
+        };
+
+        let mut sample_num = self.seq[track_num].first_sample;
+        let mut ts_accum = self.seq[track_num].first_ts;
+
+        let default_dur = traf
+            .tfhd
+            .default_sample_duration
+            .unwrap_or(self.mvex.trexs[track_num].default_sample_duration);
+
+        for trun in traf.truns.iter() {
+            // Get the total duration of this track run.
+            let trun_dur = trun.total_duration(default_dur);
+
+            // If the timestamp after the track run is greater than the desired timestamp, then the
+            // desired sample must be in this run of samples.
+            if ts_accum + trun_dur > ts {
+                sample_num += trun.ts_sample(ts - ts_accum, default_dur);
+                return Ok(Some(sample_num));
+            }
+
+            sample_num += trun.sample_count;
+            ts_accum += trun_dur;
+        }
+
+        Ok(None)
+    }
+
+    fn sample_data(
+        &self,
+        track_num: usize,
+        sample_num: u32,
+        get_offset: bool,
+    ) -> Result<SampleDataDesc> {
+        // Get the track fragment associated with track_num.
+        let traf = self.try_get_traf(track_num).unwrap();
+
+        // If an explicit anchor-point is set, then use that for the position, otherwise use the
+        // first-byte of the enclosing moof atom.
+        let traf_base_pos = match traf.tfhd.base_data_offset {
+            Some(pos) => pos,
+            _ => self.moof.moof_base_pos,
+        };
+
+        let mut sample_num_rel = sample_num - self.seq[track_num].first_sample;
+        let mut trun_offset = traf_base_pos;
+
+        let default_size =
+            traf.tfhd.default_sample_size.unwrap_or(self.mvex.trexs[track_num].default_sample_size);
+
+        for trun in traf.truns.iter() {
+            // If a data offset is present for this track fragment run, then calculate the new base
+            // position for the run. When a data offset is not present, do nothing because this run
+            // follows the previous run.
+            if let Some(offset) = trun.data_offset {
+                // The offset for the run is relative to the anchor-point defined in the track
+                // fragment header.
+                trun_offset = if offset.is_negative() {
+                    traf_base_pos - u64::from(offset.wrapping_abs() as u32)
+                }
+                else {
+                    traf_base_pos + offset as u64
+                };
+            }
+
+            if sample_num_rel < trun.sample_count {
+                let (offset, size) = if get_offset {
+                    // Get the size and offset of the sample.
+                    let (offset, size) = trun.sample_offset(sample_num_rel, default_size);
+                    (Some(offset), size)
+                }
+                else {
+                    // Just get the size of the sample.
+                    let size = trun.sample_size(sample_num_rel, default_size);
+                    (None, size)
+                };
+
+                return Ok(SampleDataDesc { base_pos: trun_offset, size, offset });
+            }
+
+            // Get the total size of the track fragment run.
+            let trun_size = trun.total_size(default_size);
+
+            sample_num_rel -= trun.sample_count;
+            trun_offset += trun_size;
+        }
+
+        decode_error("isomp4: invalid sample index")
+    }
+
+    fn track_sample_range(&self, track_num: usize) -> Range<u32> {
+        debug_assert!(track_num < self.seq.len());
+
+        let track = &self.seq[track_num];
+        track.first_sample..track.first_sample + track.total_sample_count
+    }
+
+    fn track_ts_range(&self, track_num: usize) -> Range<u64> {
+        debug_assert!(track_num < self.seq.len());
+
+        let track = &self.seq[track_num];
+        track.first_ts..track.first_ts + track.total_sample_duration
+    }
+}
+
+fn get_chunk_offset(
+    stco: &Option<StcoAtom>,
+    co64: &Option<Co64Atom>,
+    chunk: usize,
+) -> Result<Option<u64>> {
+    // Get the offset from either the stco or co64 atoms.
+    if let Some(stco) = stco.as_ref() {
+        // 32-bit offset
+        if let Some(offset) = stco.chunk_offsets.get(chunk) {
+            Ok(Some(u64::from(*offset)))
+        }
+        else {
+            decode_error("isomp4: missing stco entry")
+        }
+    }
+    else if let Some(co64) = co64.as_ref() {
+        // 64-bit offset
+        if let Some(offset) = co64.chunk_offsets.get(chunk) {
+            Ok(Some(*offset))
+        }
+        else {
+            decode_error("isomp4: missing co64 entry")
+        }
+    }
+    else {
+        // This should never happen because it is mandatory to have either a stco or co64 atom.
+        decode_error("isomp4: missing stco or co64 atom")
+    }
+}
+
+pub struct MoovSegment {
+    moov: MoovAtom,
+}
+
+impl MoovSegment {
+    /// Instantiate a segment from the provide moov atom.
+    pub fn new(moov: MoovAtom) -> MoovSegment {
+        MoovSegment { moov }
+    }
+}
+
+impl StreamSegment for MoovSegment {
+    fn sequence_num(&self) -> u32 {
+        // The segment defined by the moov atom is always 0.
+        0
+    }
+
+    fn sample_timing(&self, track_num: usize, sample_num: u32) -> Result<Option<SampleTiming>> {
+        // Get the trak atom associated with track_num.
+        debug_assert!(track_num < self.moov.traks.len());
+
+        let trak = &self.moov.traks[track_num];
+
+        // Find the sample timing. Note, complexity of O(N).
+        let timing = trak.mdia.minf.stbl.stts.find_timing_for_sample(sample_num);
+
+        if let Some((ts, dur)) = timing {
+            Ok(Some(SampleTiming { ts, dur }))
+        }
+        else {
+            Ok(None)
+        }
+    }
+
+    fn ts_sample(&self, track_num: usize, ts: u64) -> Result<Option<u32>> {
+        // Get the trak atom associated with track_num.
+        debug_assert!(track_num < self.moov.traks.len());
+
+        let trak = &self.moov.traks[track_num];
+
+        // Find the sample timestamp. Note, complexity of O(N).
+        Ok(trak.mdia.minf.stbl.stts.find_sample_for_timestamp(ts))
+    }
+
+    fn sample_data(
+        &self,
+        track_num: usize,
+        sample_num: u32,
+        get_offset: bool,
+    ) -> Result<SampleDataDesc> {
+        // Get the trak atom associated with track_num.
+        debug_assert!(track_num < self.moov.traks.len());
+
+        let trak = &self.moov.traks[track_num];
+
+        // Get the constituent tables.
+        let stsz = &trak.mdia.minf.stbl.stsz;
+        let stsc = &trak.mdia.minf.stbl.stsc;
+        let stco = &trak.mdia.minf.stbl.stco;
+        let co64 = &trak.mdia.minf.stbl.co64;
+
+        // Find the sample-to-chunk mapping. Note, complexity of O(log N).
+        let group = stsc
+            .find_entry_for_sample(sample_num)
+            .ok_or(Error::DecodeError("invalid sample index"))?;
+
+        // Index of the sample relative to the chunk group.
+        let sample_in_group = sample_num - group.first_sample;
+
+        // Index of the chunk containing the sample relative to the chunk group.
+        let chunk_in_group = sample_in_group / group.samples_per_chunk;
+
+        // Index of the chunk containing the sample relative to the entire stream.
+        let chunk_in_stream = group.first_chunk + chunk_in_group;
+
+        // Get the byte position of the first sample of the chunk containing the sample.
+        let base_pos = get_chunk_offset(stco, co64, chunk_in_stream as usize)?.unwrap();
+
+        // Determine the absolute sample byte position if requested by calculating the offset of
+        // the sample from the base position of the chunk.
+        let offset = if get_offset {
+            // Index of the sample relative to the chunk containing the sample.
+            let sample_in_chunk = sample_in_group - (chunk_in_group * group.samples_per_chunk);
+
+            // Calculat the byte offset of the sample relative to the chunk containing it.
+            let offset = match stsz.sample_sizes {
+                SampleSize::Constant(size) => {
+                    // Constant size samples can be calculated directly.
+                    u64::from(sample_in_chunk) * u64::from(size)
+                }
+                SampleSize::Variable(ref entries) => {
+                    // For variable size samples, sum the sizes of all the samples preceeding the
+                    // desired sample in the chunk.
+                    let chunk_first_sample = (sample_num - sample_in_chunk) as usize;
+
+                    if let Some(samples) = entries.get(chunk_first_sample..sample_num as usize) {
+                        samples.iter().map(|&size| u64::from(size)).sum()
+                    }
+                    else {
+                        return decode_error("isomp4: missing one or more stsz entries");
+                    }
+                }
+            };
+
+            Some(offset)
+        }
+        else {
+            None
+        };
+
+        // Get the size in bytes of the sample.
+        let size = match stsz.sample_sizes {
+            SampleSize::Constant(size) => size,
+            SampleSize::Variable(ref entries) => {
+                if let Some(size) = entries.get(sample_num as usize) {
+                    *size
+                }
+                else {
+                    return decode_error("isomp4: missing stsz entry");
+                }
+            }
+        };
+
+        Ok(SampleDataDesc { base_pos, size, offset })
+    }
+
+    fn track_sample_range(&self, track_num: usize) -> Range<u32> {
+        debug_assert!(track_num < self.moov.traks.len());
+
+        0..self.moov.traks[track_num].mdia.minf.stbl.stsz.sample_count
+    }
+
+    fn track_ts_range(&self, track_num: usize) -> Range<u64> {
+        debug_assert!(track_num < self.moov.traks.len());
+
+        0..self.moov.traks[track_num].mdia.minf.stbl.stts.total_duration
+    }
+}

src-tauri/src/audio.rs

@@ -890,7 +890,13 @@ impl MediaSource for SizedCursorSource {
 // Implements Iterator<Item = i16> + Source — identical interface to
 // rodio::Decoder, so the rest of the source chain is unchanged.
 
+/// Max retries for IO/packet-read errors (fatal — network drop, truncated file).
 const DECODE_MAX_RETRIES: usize = 3;
+/// Max *consecutive* DecodeErrors before giving up on a file.
+/// Non-fatal errors like "invalid main_data offset" are silently dropped up to
+/// this limit so a handful of corrupt MP3 frames never aborts an otherwise
+/// playable track (VLC-style frame dropping).
+const MAX_CONSECUTIVE_DECODE_ERRORS: usize = 100;
 
 struct SizedDecoder {
     decoder: Box<dyn symphonia::core::codecs::Decoder>,
@@ -899,6 +905,9 @@ struct SizedDecoder {
     total_duration: Option<Time>,
     buffer: SampleBuffer<i16>,
     spec: SignalSpec,
+    /// Counts consecutive DecodeErrors in the hot-path. Reset to 0 on every
+    /// successfully decoded frame. Used to detect fully undecodable streams.
+    consecutive_decode_errors: usize,
 }
 
 impl SizedDecoder {
@@ -923,14 +932,25 @@ impl SizedDecoder {
             hint.with_extension(ext);
         }
         let format_opts = FormatOptions {
-            enable_gapless: true,
+            // Disable gapless parsing — Symphonia 0.5.5 crashes on `edts` atoms
+            // present in older iTunes-purchased M4A files.
+            enable_gapless: false,
+            ..Default::default()
+        };
+
+        let meta_opts = symphonia::core::meta::MetadataOptions {
+            // Cap embedded cover art at 8 MiB so oversized MJPEG images in
+            // iTunes M4A files don't choke the parser.
+            limit_visual_bytes: symphonia::core::meta::Limit::Maximum(8 * 1024 * 1024),
             ..Default::default()
         };
 
         let probed = symphonia::default::get_probe()
-            .format(&hint, mss, &format_opts, &MetadataOptions::default())
+            .format(&hint, mss, &format_opts, &meta_opts)
             .map_err(|e| {
                 let hint_str = format_hint.unwrap_or("unknown");
+                // Always print the raw Symphonia error to the terminal for diagnosis.
+                eprintln!("[psysonic] probe failed (hint={hint_str}): {e}");
                 if e.to_string().to_lowercase().contains("unsupported") {
                     format!("unsupported format: .{hint_str} files cannot be played (no demuxer)")
                 } else {
@@ -941,8 +961,17 @@ impl SizedDecoder {
         let track = probed.format
             .tracks()
             .iter()
-            .find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
-            .ok_or_else(|| "no playable audio track found in file".to_string())?;
+            // Explicitly select only audio tracks: must have a valid codec and a
+            // sample_rate. This skips MJPEG cover-art streams that iTunes M4A
+            // files embed as a secondary video track.
+            .find(|t| {
+                t.codec_params.codec != CODEC_TYPE_NULL
+                    && t.codec_params.sample_rate.is_some()
+            })
+            .ok_or_else(|| {
+                eprintln!("[psysonic] no audio track found among {} tracks", probed.format.tracks().len());
+                "no playable audio track found in file".to_string()
+            })?;
 
         let track_id = track.id;
         let total_duration = track.codec_params.time_base
@@ -952,6 +981,7 @@ impl SizedDecoder {
         let mut decoder = symphonia::default::get_codecs()
             .make(&track.codec_params, &DecoderOptions::default())
             .map_err(|e| {
+                eprintln!("[psysonic] codec init failed: {e}");
                 if e.to_string().to_lowercase().contains("unsupported") {
                     "unsupported codec: no decoder available for this audio format".to_string()
                 } else {
@@ -962,6 +992,8 @@ impl SizedDecoder {
         let mut format = probed.format;
 
         // Decode the first packet to initialise spec + buffer.
+        // DecodeErrors (e.g. "invalid main_data offset") are non-fatal: drop the
+        // frame and try the next packet up to MAX_CONSECUTIVE_DECODE_ERRORS times.
         let mut decode_errors: usize = 0;
         let decoded = loop {
             let packet = match format.next_packet() {
@@ -969,18 +1001,28 @@ impl SizedDecoder {
                 Err(symphonia::core::errors::Error::IoError(_)) => {
                     break decoder.last_decoded();
                 }
-                Err(e) => return Err(format!("could not read audio data: {e}")),
+                Err(e) => {
+                    eprintln!("[psysonic] next_packet error: {e}");
+                    return Err(format!("could not read audio data: {e}"));
+                }
             };
-            if packet.track_id() != track_id { continue; }
+            if packet.track_id() != track_id {
+                eprintln!("[psysonic] skipping packet for track {} (want {})", packet.track_id(), track_id);
+                continue;
+            }
             match decoder.decode(&packet) {
                 Ok(decoded) => break decoded,
-                Err(symphonia::core::errors::Error::DecodeError(_)) => {
+                Err(symphonia::core::errors::Error::DecodeError(ref msg)) => {
                     decode_errors += 1;
-                    if decode_errors > DECODE_MAX_RETRIES {
-                        return Err("too many decode errors — file may be corrupt".into());
+                    eprintln!("[psysonic] init: dropped corrupt frame #{decode_errors}: {msg}");
+                    if decode_errors >= MAX_CONSECUTIVE_DECODE_ERRORS {
+                        return Err("too many consecutive decode errors during init — file may be corrupt".into());
                     }
                 }
-                Err(e) => return Err(format!("audio decode error: {e}")),
+                Err(e) => {
+                    eprintln!("[psysonic] fatal decode error: {e}");
+                    return Err(format!("audio decode error: {e}"));
+                }
             }
         };
 
@@ -994,6 +1036,7 @@ impl SizedDecoder {
             total_duration,
             buffer,
             spec,
+            consecutive_decode_errors: 0,
         })
     }
 
@@ -1030,16 +1073,19 @@ impl SizedDecoder {
             if packet.track_id() != track_id { continue; }
             match decoder.decode(&packet) {
                 Ok(d) => break d,
-                Err(symphonia::core::errors::Error::DecodeError(_)) => {
+                Err(symphonia::core::errors::Error::DecodeError(ref msg)) => {
                     errors += 1;
-                    if errors > DECODE_MAX_RETRIES { return Err("radio: too many decode errors".into()); }
+                    eprintln!("[psysonic] radio init: dropped corrupt frame #{errors}: {msg}");
+                    if errors >= MAX_CONSECUTIVE_DECODE_ERRORS {
+                        return Err("radio: too many consecutive decode errors".into());
+                    }
                 }
                 Err(e) => return Err(format!("radio: decode error: {e}")),
             }
         };
         let spec = decoded.spec().to_owned();
         let buffer = Self::make_buffer(decoded, &spec);
-        Ok(SizedDecoder { decoder, current_frame_offset: 0, format, total_duration, buffer, spec })
+        Ok(SizedDecoder { decoder, current_frame_offset: 0, format, total_duration, buffer, spec, consecutive_decode_errors: 0 })
     }
 
     #[inline]
@@ -1089,18 +1135,45 @@ impl Iterator for SizedDecoder {
     #[inline]
     fn next(&mut self) -> Option<i16> {
         if self.current_frame_offset >= self.buffer.len() {
-            let packet = self.format.next_packet().ok()?;
-            let mut decoded = self.decoder.decode(&packet);
-            for _ in 0..DECODE_MAX_RETRIES {
-                if decoded.is_err() {
-                    let p = self.format.next_packet().ok()?;
-                    decoded = self.decoder.decode(&p);
+            // Loop until a decodable packet is found or the stream ends.
+            // DecodeErrors (e.g. MP3 "invalid main_data offset") are non-fatal:
+            // drop the frame and advance to the next packet. IO errors and a
+            // clean end-of-stream both terminate the iterator normally.
+            loop {
+                let packet = self.format.next_packet().ok()?;
+                match self.decoder.decode(&packet) {
+                    Ok(decoded) => {
+                        self.consecutive_decode_errors = 0;
+                        decoded.spec().clone_into(&mut self.spec);
+                        self.buffer = Self::make_buffer(decoded, &self.spec);
+                        self.current_frame_offset = 0;
+                        break;
+                    }
+                    Err(symphonia::core::errors::Error::DecodeError(ref _msg)) => {
+                        self.consecutive_decode_errors += 1;
+                        // Log sparingly: first drop, then every 10th to avoid spam.
+                        #[cfg(debug_assertions)]
+                        if self.consecutive_decode_errors == 1
+                            || self.consecutive_decode_errors % 10 == 0
+                        {
+                            eprintln!(
+                                "[psysonic] dropped corrupt frame #{}: {msg}",
+                                self.consecutive_decode_errors
+                            );
+                        }
+                        if self.consecutive_decode_errors >= MAX_CONSECUTIVE_DECODE_ERRORS {
+                            #[cfg(debug_assertions)]
+                            eprintln!(
+                                "[psysonic] {MAX_CONSECUTIVE_DECODE_ERRORS} consecutive decode \
+                                 failures — stream appears unrecoverable, stopping"
+                            );
+                            return None;
+                        }
+                        // continue → fetch next packet
+                    }
+                    Err(_) => return None, // IO error or fatal codec error → end of stream
                 }
             }
-            let decoded = decoded.ok()?;
-            decoded.spec().clone_into(&mut self.spec);
-            self.buffer = Self::make_buffer(decoded, &self.spec);
-            self.current_frame_offset = 0;
         }
 
         let sample = *self.buffer.samples().get(self.current_frame_offset)?;
@@ -1201,8 +1274,17 @@ fn parse_gapless_info(data: &[u8]) -> GaplessInfo {
         None => return GaplessInfo::default(),
     };
 
-    // Collect printable ASCII bytes after the tag (skip nulls / control chars)
-    let tail = &data[pos + 8..data.len().min(pos + 8 + 256)];
+    // In M4A/iTunes files the key is followed by a binary 'data' atom header
+    // (16 bytes: size[4] + "data"[4] + type_flags[4] + locale[4]) before the
+    // actual value string. Search for the " 00000000 " sentinel that every
+    // iTunSMPB value starts with to locate the true start of the text.
+    let search_end = data.len().min(pos + 8 + 128);
+    let search_window = &data[pos + 8..search_end];
+    let value_start = find_subsequence(search_window, b" 00000000 ")
+        .map(|off| pos + 8 + off)
+        .unwrap_or(pos + 8);
+
+    let tail = &data[value_start..data.len().min(value_start + 256)];
     let text: String = tail.iter()
         .map(|&b| b as char)
         .filter(|c| c.is_ascii_hexdigit() || *c == ' ')
@@ -1602,6 +1684,7 @@ pub fn create_engine() -> (AudioEngine, std::thread::JoinHandle<()>) {
         http_client: reqwest::Client::builder()
             .timeout(Duration::from_secs(30))
             .use_rustls_tls()
+            .user_agent(format!("psysonic/{}", env!("CARGO_PKG_VERSION")))
             .build()
             .unwrap_or_default(),
         eq_gains: Arc::new(std::array::from_fn(|_| AtomicU32::new(0f32.to_bits()))),
@@ -1687,6 +1770,24 @@ async fn fetch_data(
     }
 
     let response = state.http_client.get(url).send().await.map_err(|e| e.to_string())?;
+    #[cfg(debug_assertions)]
+    {
+        let status = response.status();
+        let ct = response.headers()
+            .get(reqwest::header::CONTENT_TYPE)
+            .and_then(|v| v.to_str().ok())
+            .unwrap_or("-");
+        let server_hdr = response.headers()
+            .get("server")
+            .and_then(|v| v.to_str().ok())
+            .unwrap_or("-");
+        // Strip auth params from URL before logging.
+        let safe_url = url.split('?').next().unwrap_or(url);
+        eprintln!(
+            "[audio] fetch {} → {} | content-type: {} | server: {}",
+            safe_url, status, ct, server_hdr
+        );
+    }
     if !response.status().is_success() {
         if state.generation.load(Ordering::SeqCst) != gen {
             return Ok(None); // superseded
@@ -2244,8 +2345,8 @@ fn spawn_progress_task(
         let mut samples_played = samples_played;
 
         loop {
-            // 100 ms tick — tight enough for responsive UI, low enough CPU cost.
-            tokio::time::sleep(Duration::from_millis(100)).await;
+            // 500 ms tick — frontend interpolates visually at 60 fps via rAF.
+            tokio::time::sleep(Duration::from_millis(500)).await;
 
             if gen_counter.load(Ordering::SeqCst) != gen {
                 break;
@@ -2782,3 +2883,75 @@ pub fn audio_set_crossfade(enabled: bool, secs: f32, state: State<'_, AudioEngin
 pub fn audio_set_gapless(enabled: bool, state: State<'_, AudioEngine>) {
     state.gapless_enabled.store(enabled, Ordering::Relaxed);
 }
+
+// ─── Device-change watcher ────────────────────────────────────────────────────
+//
+// Polls the OS default output device every 3 s.  When it changes (Bluetooth
+// headphones connecting, USB DAC plugging in, etc.) the stream is reopened on
+// the new device and `audio:device-changed` is emitted so the frontend can
+// restart playback.  The old Sink is dropped here — it was bound to the
+// now-closed OutputStream and can no longer produce audio on any device.
+
+pub fn start_device_watcher(engine: &AudioEngine, app: tauri::AppHandle) {
+    let reopen_tx     = engine.stream_reopen_tx.clone();
+    let stream_handle = engine.stream_handle.clone();
+    let stream_rate   = engine.stream_sample_rate.clone();
+    let current       = engine.current.clone();
+    let fading_out    = engine.fading_out_sink.clone();
+
+    tauri::async_runtime::spawn(async move {
+        let mut last_name: Option<String> = tauri::async_runtime::spawn_blocking(|| {
+            use rodio::cpal::traits::{DeviceTrait, HostTrait};
+            rodio::cpal::default_host()
+                .default_output_device()
+                .and_then(|d| d.name().ok())
+        }).await.unwrap_or(None);
+
+        loop {
+            tokio::time::sleep(Duration::from_secs(3)).await;
+
+            let current_name: Option<String> = tauri::async_runtime::spawn_blocking(|| {
+                use rodio::cpal::traits::{DeviceTrait, HostTrait};
+                rodio::cpal::default_host()
+                    .default_output_device()
+                    .and_then(|d| d.name().ok())
+            }).await.unwrap_or(None);
+
+            if current_name == last_name {
+                continue;
+            }
+
+            last_name = current_name.clone();
+
+            // Only act if there is actually a device to open.
+            let Some(_new_name) = current_name else { continue };
+
+            // Debounce: give the OS time to finish configuring the new device.
+            tokio::time::sleep(Duration::from_millis(500)).await;
+
+            let rate = stream_rate.load(Ordering::Relaxed);
+            let reopen_tx2 = reopen_tx.clone();
+            let new_handle = tauri::async_runtime::spawn_blocking(move || {
+                let (reply_tx, reply_rx) =
+                    std::sync::mpsc::sync_channel::<rodio::OutputStreamHandle>(0);
+                if reopen_tx2.send((rate, false, reply_tx)).is_err() {
+                    return None; // audio thread exited
+                }
+                reply_rx.recv_timeout(Duration::from_secs(5)).ok()
+            }).await.unwrap_or(None);
+
+            let Some(handle) = new_handle else {
+                eprintln!("[psysonic] device-watcher: stream reopen timed out");
+                continue;
+            };
+
+            *stream_handle.lock().unwrap() = handle;
+
+            // Drop the old Sink — it was bound to the now-closed OutputStream.
+            if let Some(s) = current.lock().unwrap().sink.take() { s.stop(); }
+            if let Some(s) = fading_out.lock().unwrap().take()   { s.stop(); }
+
+            app.emit("audio:device-changed", ()).ok();
+        }
+    });
+}

src-tauri/src/discord.rs

@@ -218,35 +218,45 @@ fn try_connect() -> Option<DiscordIpcClient> {
 
 /// Update the Discord Rich Presence activity.
 ///
-/// - `elapsed_secs`: seconds already played. `None` when paused — Discord shows
-///   the song/artist without a running timer.
-/// - `cover_art_url`: optional direct URL to album artwork. If None, tries to
-///   fetch from iTunes Search API using artist + album.
+/// - `is_playing`: true = playing (timer shown), false = paused (no timer, state shows "Paused").
+/// - `elapsed_secs`: seconds already played. `None` when paused — no timestamp is sent so
+///   Discord stops any running timer.
+/// - `cover_art_url`: optional direct URL to album artwork.
+/// - `fetch_itunes_covers`: if true, fetch artwork from the iTunes Search API when no
+///   `cover_art_url` is provided. If false (default), fall back to the Psysonic app icon
+///   without making any external request — required for privacy opt-in.
 #[tauri::command]
 pub async fn discord_update_presence(
     state: tauri::State<'_, DiscordState>,
     title: String,
     artist: String,
     album: Option<String>,
+    is_playing: bool,
     elapsed_secs: Option<f64>,
     cover_art_url: Option<String>,
+    fetch_itunes_covers: bool,
 ) -> Result<(), String> {
     // Resolve artwork on a dedicated blocking thread — reqwest::blocking must not
     // run on the Tokio async executor directly.
+    // Only hit the iTunes API if the user has explicitly opted in.
     let artwork_url: Option<String> = if let Some(url) = cover_art_url {
         Some(url)
-    } else if let Some(ref album_name) = album {
-        let http_client = state.http_client.clone();
-        let cache = Arc::clone(&state.artwork_cache);
-        let artist_c = artist.clone();
-        let album_c = album_name.clone();
-        let title_c = title.clone();
-        tokio::task::spawn_blocking(move || {
-            search_itunes_artwork(&http_client, &cache, &artist_c, &album_c, &title_c)
-        })
-        .await
-        .ok()
-        .flatten()
+    } else if fetch_itunes_covers {
+        if let Some(ref album_name) = album {
+            let http_client = state.http_client.clone();
+            let cache = Arc::clone(&state.artwork_cache);
+            let artist_c = artist.clone();
+            let album_c = album_name.clone();
+            let title_c = title.clone();
+            tokio::task::spawn_blocking(move || {
+                search_itunes_artwork(&http_client, &cache, &artist_c, &album_c, &title_c)
+            })
+            .await
+            .ok()
+            .flatten()
+        } else {
+            None
+        }
     } else {
         None
     };
@@ -280,21 +290,40 @@ pub async fn discord_update_presence(
             .large_text(large_text)
     };
 
+    // When paused, show "Paused" as the state text (replaces artist name).
+    let state_text: String = if is_playing {
+        artist.clone()
+    } else {
+        "Paused".to_string()
+    };
+
+    // ActivityType::Listening causes the Discord client to auto-start a running
+    // timer from "now" even when no timestamps are provided. Switch to Playing
+    // when paused — Playing only shows a timer when timestamps are explicitly set.
+    let activity_type = if is_playing {
+        ActivityType::Listening
+    } else {
+        ActivityType::Playing
+    };
+
     let mut activity = Activity::new()
-        .activity_type(ActivityType::Listening)
+        .activity_type(activity_type)
         .details(&title)
-        .state(&artist)
+        .state(&state_text)
         .assets(assets);
 
     // Start timestamp: Discord auto-counts up from this point. We back-calculate
     // it so the displayed elapsed time matches the actual playback position.
-    if let Some(elapsed) = elapsed_secs {
-        let now = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_secs() as i64;
-        let start = now - elapsed.floor() as i64;
-        activity = activity.timestamps(Timestamps::new().start(start));
+    // Only set when playing — Playing type without timestamps shows no timer.
+    if is_playing {
+        if let Some(elapsed) = elapsed_secs {
+            let now = std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_secs() as i64;
+            let start = now - elapsed.floor() as i64;
+            activity = activity.timestamps(Timestamps::new().start(start));
+        }
     }
 
     if client.set_activity(activity).is_err() {

src-tauri/src/lib.rs

@@ -3,9 +3,11 @@
 
 mod audio;
 mod discord;
+#[cfg(target_os = "windows")]
+mod taskbar_win;
 
 use std::collections::HashMap;
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 use std::sync::atomic::Ordering;
 
 use tauri::{
@@ -18,6 +20,13 @@ use tauri::{
 /// Prevents on_shortcut() accumulating duplicate handlers across JS reloads (HMR / StrictMode).
 type ShortcutMap = Mutex<HashMap<String, String>>;
 
+/// Maximum number of offline track downloads that can run concurrently.
+/// The frontend queues more tasks than this; Rust is the real throttle.
+const MAX_DL_CONCURRENCY: usize = 4;
+
+/// Shared semaphore that caps simultaneous `download_track_offline` executions.
+type DownloadSemaphore = Arc<tokio::sync::Semaphore>;
+
 /// Holds the live system-tray icon handle.  `None` means the tray is currently hidden/removed.
 /// Dropping the inner `TrayIcon` fully removes it from the OS notification area on all platforms.
 type TrayState = Mutex<Option<TrayIcon>>;
@@ -36,6 +45,19 @@ fn exit_app(app_handle: tauri::AppHandle) {
     app_handle.exit(0);
 }
 
+/// Toggle native window decorations at runtime (Linux custom title bar opt-out).
+#[tauri::command]
+fn set_window_decorations(enabled: bool, app_handle: tauri::AppHandle) {
+    if let Some(win) = app_handle.get_webview_window("main") {
+        let _ = win.set_decorations(enabled);
+        // Re-enabling native decorations on GTK causes the window manager to
+        // re-stack the window, which drops focus. Bring it back immediately.
+        if enabled {
+            let _ = win.set_focus();
+        }
+    }
+}
+
 
 /// Authenticate with Navidrome's own REST API and return a Bearer token.
 async fn navidrome_token(server_url: &str, username: &str, password: &str) -> Result<String, String> {
@@ -228,6 +250,146 @@ async fn fetch_url_bytes(url: String) -> Result<(Vec<u8>, String), String> {
     Ok((bytes.to_vec(), content_type))
 }
 
+/// Fetch a JSON API endpoint through Rust to bypass CORS/WebView networking restrictions.
+/// Returns the response body as a UTF-8 string for parsing on the JS side.
+#[tauri::command]
+async fn fetch_json_url(url: String) -> Result<String, String> {
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(10))
+        .build()
+        .map_err(|e| e.to_string())?;
+    let resp = client
+        .get(&url)
+        .header("User-Agent", "psysonic/1.0")
+        .header("Accept", "application/json")
+        .send()
+        .await
+        .map_err(|e| e.to_string())?
+        .error_for_status()
+        .map_err(|e| e.to_string())?;
+    let text = resp.text().await.map_err(|e| e.to_string())?;
+    Ok(text)
+}
+
+/// ICY metadata response returned to the frontend.
+#[derive(serde::Serialize)]
+struct IcyMetadata {
+    /// The `StreamTitle` from the inline ICY metadata block in the stream (e.g. `"Artist - Title"`).
+    stream_title: Option<String>,
+    /// Value of the `icy-name` response header.
+    icy_name: Option<String>,
+    /// Value of the `icy-genre` response header.
+    icy_genre: Option<String>,
+    /// Value of the `icy-url` response header.
+    icy_url: Option<String>,
+    /// Value of the `icy-description` response header.
+    icy_description: Option<String>,
+}
+
+/// Fetch ICY in-stream metadata from a radio stream URL.
+///
+/// Sends a GET request with `Icy-MetaData: 1` and reads just enough bytes
+/// (up to `icy-metaint` audio bytes plus the following metadata block) to
+/// extract the `StreamTitle`.  The connection is dropped as soon as the
+/// first metadata chunk has been parsed, so bandwidth usage is minimal.
+#[tauri::command]
+async fn fetch_icy_metadata(url: String) -> Result<IcyMetadata, String> {
+    use futures_util::StreamExt;
+
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(15))
+        .build()
+        .map_err(|e| e.to_string())?;
+
+    let resp = client
+        .get(&url)
+        .header("Icy-MetaData", "1")
+        .header("User-Agent", "psysonic/1.0")
+        .send()
+        .await
+        .map_err(|e| e.to_string())?;
+
+    // Harvest ICY headers before consuming the body.
+    let headers = resp.headers();
+    let icy_name        = headers.get("icy-name").and_then(|v| v.to_str().ok()).map(str::to_string);
+    let icy_genre       = headers.get("icy-genre").and_then(|v| v.to_str().ok()).map(str::to_string);
+    let icy_url         = headers.get("icy-url").and_then(|v| v.to_str().ok()).map(str::to_string);
+    let icy_description = headers.get("icy-description").and_then(|v| v.to_str().ok()).map(str::to_string);
+    let metaint: Option<usize> = headers
+        .get("icy-metaint")
+        .and_then(|v| v.to_str().ok())
+        .and_then(|s| s.parse().ok());
+
+    // If the server doesn't advertise a metaint we can still return header info.
+    let Some(metaint) = metaint else {
+        return Ok(IcyMetadata { stream_title: None, icy_name, icy_genre, icy_url, icy_description });
+    };
+
+    // Cap metaint at 64 KiB to avoid reading unreasonably large audio chunks.
+    let metaint = metaint.min(65_536);
+    let needed  = metaint + 1; // +1 for the metadata-length byte
+
+    let mut buf: Vec<u8> = Vec::with_capacity(needed + 256);
+    let mut stream = resp.bytes_stream();
+
+    while buf.len() < needed {
+        let Some(chunk) = stream.next().await else { break };
+        let chunk = chunk.map_err(|e| e.to_string())?;
+        buf.extend_from_slice(&chunk);
+    }
+
+    if buf.len() < needed {
+        // Stream ended before we reached the metadata block.
+        return Ok(IcyMetadata { stream_title: None, icy_name, icy_genre, icy_url, icy_description });
+    }
+
+    // The byte immediately after `metaint` audio bytes encodes metadata length:
+    //   actual_bytes = length_byte * 16
+    let meta_len = buf[metaint] as usize * 16;
+    if meta_len == 0 {
+        return Ok(IcyMetadata { stream_title: None, icy_name, icy_genre, icy_url, icy_description });
+    }
+
+    // We may need to read a few more chunks to get the full metadata block.
+    let total_needed = needed + meta_len;
+    while buf.len() < total_needed {
+        let Some(chunk) = stream.next().await else { break };
+        let chunk = chunk.map_err(|e| e.to_string())?;
+        buf.extend_from_slice(&chunk);
+    }
+
+    let meta_start = needed; // index of first metadata byte
+    let meta_end   = (meta_start + meta_len).min(buf.len());
+    let meta_bytes = &buf[meta_start..meta_end];
+
+    // ICY metadata is Latin-1 encoded; convert to a Rust String lossily.
+    let meta_str: String = meta_bytes
+        .iter()
+        .map(|&b| if b == 0 { '\0' } else { b as char })
+        .collect::<String>();
+
+    // Parse StreamTitle='...' — value ends at the next unescaped single-quote.
+    let stream_title = meta_str
+        .split("StreamTitle='")
+        .nth(1)
+        .and_then(|s| {
+            // Find closing quote that is NOT preceded by a backslash.
+            let mut prev = '\0';
+            let mut end = s.len();
+            for (i, c) in s.char_indices() {
+                if c == '\'' && prev != '\\' {
+                    end = i;
+                    break;
+                }
+                prev = c;
+            }
+            let title = s[..end].trim().to_string();
+            if title.is_empty() { None } else { Some(title) }
+        });
+
+    Ok(IcyMetadata { stream_title, icy_name, icy_genre, icy_url, icy_description })
+}
+
 /// Proxy Last.fm API calls through Rust/reqwest to avoid WebView networking restrictions.
 /// `params` is a list of [key, value] pairs (method must be included).
 /// If `sign` is true an api_sig is computed. If `get` is true, a GET request is made.
@@ -386,8 +548,32 @@ fn mpris_set_playback(
         .map_err(|e| format!("MPRIS set_playback failed: {e:?}"))
 }
 
+/// Returns true if `path` is an accessible directory (used for pre-flight checks in the frontend).
+#[tauri::command]
+fn check_dir_accessible(path: String) -> bool {
+    std::path::Path::new(&path).is_dir()
+}
+
 // ─── Offline Track Cache ──────────────────────────────────────────────────────
 
+/// Streams an HTTP response body directly to `dest_path` in small chunks.
+/// Never buffers the full file in memory — keeps RAM flat regardless of file size.
+async fn stream_to_file(response: reqwest::Response, dest_path: &std::path::Path) -> Result<(), String> {
+    use futures_util::StreamExt;
+    use tokio::io::AsyncWriteExt;
+
+    let mut file = tokio::fs::File::create(dest_path)
+        .await
+        .map_err(|e| e.to_string())?;
+    let mut stream = response.bytes_stream();
+    while let Some(chunk) = stream.next().await {
+        let chunk = chunk.map_err(|e| e.to_string())?;
+        file.write_all(&chunk).await.map_err(|e| e.to_string())?;
+    }
+    file.flush().await.map_err(|e| e.to_string())?;
+    Ok(())
+}
+
 /// Downloads a single track to the app's offline cache directory.
 /// Returns the absolute file path so TypeScript can store it and later
 /// construct a `psysonic-local://<path>` URL for the audio engine.
@@ -398,6 +584,7 @@ async fn download_track_offline(
     url: String,
     suffix: String,
     custom_dir: Option<String>,
+    dl_sem: tauri::State<'_, DownloadSemaphore>,
     app: tauri::AppHandle,
 ) -> Result<String, String> {
     // Determine base cache directory.
@@ -423,11 +610,15 @@ async fn download_track_offline(
     let file_path = cache_dir.join(format!("{}.{}", track_id, suffix));
     let path_str = file_path.to_string_lossy().to_string();
 
-    // Already cached — skip re-download.
+    // Already cached — skip re-download (no semaphore needed).
     if file_path.exists() {
         return Ok(path_str);
     }
 
+    // Acquire a download slot. The permit is held for the duration of the HTTP transfer
+    // and released automatically when this function returns (success or error).
+    let _permit = dl_sem.acquire().await.map_err(|e| e.to_string())?;
+
     let client = reqwest::Client::builder()
         .timeout(std::time::Duration::from_secs(120))
         .build()
@@ -437,8 +628,14 @@ async fn download_track_offline(
     if !response.status().is_success() {
         return Err(format!("HTTP {}", response.status().as_u16()));
     }
-    let bytes = response.bytes().await.map_err(|e| e.to_string())?;
-    tokio::fs::write(&file_path, &bytes)
+
+    // Stream directly to a .part file; rename on success to avoid partial files.
+    let part_path = file_path.with_extension(format!("{suffix}.part"));
+    if let Err(e) = stream_to_file(response, &part_path).await {
+        let _ = tokio::fs::remove_file(&part_path).await;
+        return Err(e);
+    }
+    tokio::fs::rename(&part_path, &file_path)
         .await
         .map_err(|e| e.to_string())?;
 
@@ -556,6 +753,378 @@ fn resolve_hot_cache_root(
     }
 }
 
+/// Returns true if the current Linux system is Arch-based
+/// (checks /etc/arch-release and /etc/os-release).
+#[tauri::command]
+fn check_arch_linux() -> bool {
+    #[cfg(target_os = "linux")]
+    {
+        if std::path::Path::new("/etc/arch-release").exists() {
+            return true;
+        }
+        if let Ok(content) = std::fs::read_to_string("/etc/os-release") {
+            for line in content.lines() {
+                let lower = line.to_lowercase();
+                if lower.starts_with("id=arch") { return true; }
+                if lower.starts_with("id_like=") && lower.contains("arch") { return true; }
+            }
+        }
+        false
+    }
+    #[cfg(not(target_os = "linux"))]
+    { false }
+}
+
+/// Progress payload emitted during an update binary download.
+#[derive(Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+struct UpdateDownloadProgress {
+    bytes: u64,
+    total: Option<u64>,
+}
+
+/// Downloads an update installer/package to the user's Downloads folder.
+/// Emits `update:download:progress` events with `{ bytes, total }` every 250 ms.
+/// Returns the final absolute file path on success.
+#[tauri::command]
+async fn download_update(url: String, filename: String, app: tauri::AppHandle) -> Result<String, String> {
+    use futures_util::StreamExt;
+    use std::time::{Duration, Instant};
+    use tokio::io::AsyncWriteExt;
+
+    const EMIT_INTERVAL: Duration = Duration::from_millis(250);
+
+    let dest_dir = app.path().download_dir().map_err(|e| e.to_string())?;
+    let dest_path = dest_dir.join(&filename);
+    let part_path = dest_dir.join(format!("{}.part", filename));
+
+    let client = reqwest::Client::builder()
+        .connect_timeout(Duration::from_secs(30))
+        .timeout(Duration::from_secs(3600))
+        .build()
+        .map_err(|e| e.to_string())?;
+
+    let response = client.get(&url).send().await.map_err(|e| e.to_string())?;
+    if !response.status().is_success() {
+        return Err(format!("HTTP {}", response.status().as_u16()));
+    }
+
+    let total = response.content_length();
+
+    let result: Result<u64, String> = async {
+        let mut file = tokio::fs::File::create(&part_path)
+            .await
+            .map_err(|e| e.to_string())?;
+
+        let mut bytes_done: u64 = 0;
+        let mut stream = response.bytes_stream();
+        let mut last_emit = Instant::now();
+
+        while let Some(chunk) = stream.next().await {
+            let chunk = chunk.map_err(|e| e.to_string())?;
+            file.write_all(&chunk).await.map_err(|e| e.to_string())?;
+            bytes_done += chunk.len() as u64;
+
+            if last_emit.elapsed() >= EMIT_INTERVAL {
+                let _ = app.emit("update:download:progress", UpdateDownloadProgress {
+                    bytes: bytes_done,
+                    total,
+                });
+                last_emit = Instant::now();
+            }
+        }
+        file.flush().await.map_err(|e| e.to_string())?;
+        Ok(bytes_done)
+    }.await;
+
+    match result {
+        Err(e) => {
+            let _ = tokio::fs::remove_file(&part_path).await;
+            Err(e)
+        }
+        Ok(bytes_done) => {
+            let _ = app.emit("update:download:progress", UpdateDownloadProgress {
+                bytes: bytes_done,
+                total: Some(bytes_done),
+            });
+            tokio::fs::rename(&part_path, &dest_path)
+                .await
+                .map_err(|e| e.to_string())?;
+            Ok(dest_path.to_string_lossy().into_owned())
+        }
+    }
+}
+
+/// Fetches synced lyrics from Netease Cloud Music for a given artist + title.
+/// Performs a track search, then fetches the LRC string for the best match.
+/// Returns `None` if no match or no lyrics are found.
+#[tauri::command]
+async fn fetch_netease_lyrics(artist: String, title: String) -> Result<Option<String>, String> {
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(8))
+        .build()
+        .map_err(|e| e.to_string())?;
+
+    let query = format!("{} {}", artist, title);
+    let params = [("s", query.as_str()), ("type", "1"), ("limit", "5")];
+    let search: serde_json::Value = client
+        .post("https://music.163.com/api/search/get")
+        .header("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36")
+        .header("Referer", "https://music.163.com")
+        .form(&params)
+        .send()
+        .await
+        .map_err(|e| e.to_string())?
+        .json()
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let song_id = match search["result"]["songs"][0]["id"].as_i64() {
+        Some(id) => id,
+        None => return Ok(None),
+    };
+
+    let lyrics: serde_json::Value = client
+        .get(format!(
+            "https://music.163.com/api/song/lyric?id={}&lv=1&kv=1&tv=-1",
+            song_id
+        ))
+        .header("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36")
+        .header("Referer", "https://music.163.com")
+        .send()
+        .await
+        .map_err(|e| e.to_string())?
+        .json()
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let lrc = lyrics["lrc"]["lyric"].as_str().unwrap_or("").trim().to_string();
+    Ok(if lrc.is_empty() { None } else { Some(lrc) })
+}
+
+/// Reads embedded synced / unsynced lyrics from a local audio file.
+///
+/// Priority order:
+///   MP3  → ID3v2 SYLT (synchronized, ms timestamps) → ID3v2 USLT (plain)
+///   FLAC → Vorbis SYNCEDLYRICS (LRC string)          → Vorbis LYRICS (plain)
+///
+/// Returns a standard LRC string (`[mm:ss.cc]line\n…`) for synced lyrics,
+/// or plain text for unsynced lyrics.  Returns `None` when no lyrics are found.
+/// Errors are silenced and mapped to `None` so the frontend falls through to the
+/// next lyrics source without crashing.
+#[tauri::command]
+fn get_embedded_lyrics(path: String) -> Option<String> {
+    use lofty::file::FileType;
+    use lofty::prelude::*;
+    use lofty::probe::Probe;
+
+    let fpath = std::path::Path::new(&path);
+    if !fpath.exists() {
+        return None;
+    }
+
+    // Detect file type from magic bytes only — no full tag read yet.
+    // guess_file_type() consumes self and returns Self, so reassign.
+    let probe = Probe::open(fpath).ok()?;
+    let probe = probe.guess_file_type().ok()?;
+    let file_type = probe.file_type();
+
+    // ── MP3 / MPEG: use the `id3` crate for SYLT / USLT ─────────────────────
+    // lofty's MpegFile::id3v2_tag field is pub(crate) — not accessible here.
+    // The `id3` crate exposes a clean public API for typed ID3v2 frames.
+    if matches!(file_type, Some(FileType::Mpeg)) {
+        use id3::{Content, Tag as Id3Tag};
+
+        if let Ok(tag) = Id3Tag::read_from_path(fpath) {
+            // 1. SYLT — millisecond-timestamped synced lyrics.
+            for frame in tag.frames() {
+                if frame.id() != "SYLT" {
+                    continue;
+                }
+                if let Content::SynchronisedLyrics(sylt) = frame.content() {
+                    // Only accept millisecond timestamps — MPEG-frame-based
+                    // timestamps can't be converted to wall-clock seconds.
+                    if sylt.timestamp_format != id3::frame::TimestampFormat::Ms {
+                        continue;
+                    }
+                    let lrc: String = sylt
+                        .content
+                        .iter()
+                        .filter_map(|(ms, text)| {
+                            let t = text.trim();
+                            if t.is_empty() {
+                                return None;
+                            }
+                            let mins = ms / 60_000;
+                            let secs = (ms % 60_000) / 1_000;
+                            let cs   = (ms % 1_000) / 10;
+                            // [mm:ss.cc] matches parseLrc's /\d+(?:\.\d*)?/ regex
+                            Some(format!("[{:02}:{:02}.{:02}]{}\n", mins, secs, cs, t))
+                        })
+                        .collect();
+                    if !lrc.is_empty() {
+                        return Some(lrc.trim_end().to_owned());
+                    }
+                }
+            }
+
+            // 2. USLT — unsynchronized lyrics, plain-text fallback.
+            for frame in tag.frames() {
+                if frame.id() != "USLT" {
+                    continue;
+                }
+                if let Content::Lyrics(uslt) = frame.content() {
+                    let text = uslt.text.trim();
+                    if !text.is_empty() {
+                        return Some(text.to_owned());
+                    }
+                }
+            }
+        }
+        return None; // MPEG file but no usable lyrics found
+    }
+
+    // ── FLAC / Vorbis / Opus / M4A: generic lofty tag API ────────────────────
+    // Vorbis SYNCEDLYRICS stores a complete LRC string in a plain comment field.
+    // It is not a known lofty ItemKey, so access it via ItemKey::Unknown.
+    let tagged = probe.read().ok()?;
+    for tag in tagged.tags() {
+        if let Some(lrc) = tag.get_string(&ItemKey::Unknown("SYNCEDLYRICS".to_owned())) {
+            let lrc = lrc.trim();
+            if !lrc.is_empty() {
+                return Some(lrc.to_owned());
+            }
+        }
+        if let Some(plain) = tag.get_string(&ItemKey::Lyrics) {
+            let plain = plain.trim();
+            if !plain.is_empty() {
+                return Some(plain.to_owned());
+            }
+        }
+    }
+
+    None
+}
+
+/// Opens a directory in the OS file manager (Explorer / Finder / Nautilus).
+/// Uses platform-specific process spawning — tauri-plugin-shell's open() only
+/// allows https:// URLs per the capability scope and fails silently for paths.
+#[tauri::command]
+fn open_folder(path: String) -> Result<(), String> {
+    #[cfg(target_os = "windows")]
+    {
+        std::process::Command::new("explorer.exe")
+            .arg(&path)
+            .spawn()
+            .map_err(|e| e.to_string())?;
+    }
+    #[cfg(target_os = "macos")]
+    {
+        std::process::Command::new("open")
+            .arg(&path)
+            .spawn()
+            .map_err(|e| e.to_string())?;
+    }
+    #[cfg(target_os = "linux")]
+    {
+        std::process::Command::new("xdg-open")
+            .arg(&path)
+            .spawn()
+            .map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
+/// Progress payload emitted to the frontend during a ZIP download.
+/// `total` is `None` when the server doesn't send a `Content-Length` header
+/// (Navidrome on-the-fly ZIPs).
+#[derive(Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+struct ZipProgress {
+    id: String,
+    bytes: u64,
+    total: Option<u64>,
+}
+
+/// Downloads a server-generated ZIP (album/playlist) directly to disk via streaming.
+/// Emits `download:zip:progress` events every 500 ms so the frontend can show
+/// live MB-counter without holding any binary data in the WebView process.
+/// Returns the final destination path on success.
+#[tauri::command]
+async fn download_zip(
+    id: String,
+    url: String,
+    dest_path: String,
+    app: tauri::AppHandle,
+) -> Result<String, String> {
+    use futures_util::StreamExt;
+    use std::time::{Duration, Instant};
+    use tokio::io::AsyncWriteExt;
+
+    const EMIT_INTERVAL: Duration = Duration::from_millis(500);
+
+    let client = reqwest::Client::builder()
+        .connect_timeout(Duration::from_secs(30))
+        .timeout(Duration::from_secs(7200)) // up to 2 h for large on-the-fly ZIPs
+        .build()
+        .map_err(|e| e.to_string())?;
+
+    let response = client.get(&url).send().await.map_err(|e| e.to_string())?;
+    if !response.status().is_success() {
+        return Err(format!("HTTP {}", response.status().as_u16()));
+    }
+
+    let total = response.content_length(); // None for Navidrome on-the-fly ZIPs
+    let part_path = format!("{dest_path}.part");
+
+    // Stream to .part file; rename on success, delete on error.
+    let result: Result<u64, String> = async {
+        let mut file = tokio::fs::File::create(&part_path)
+            .await
+            .map_err(|e| e.to_string())?;
+
+        let mut bytes_done: u64 = 0;
+        let mut stream = response.bytes_stream();
+        let mut last_emit = Instant::now();
+
+        while let Some(chunk) = stream.next().await {
+            let chunk = chunk.map_err(|e| e.to_string())?;
+            file.write_all(&chunk).await.map_err(|e| e.to_string())?;
+            bytes_done += chunk.len() as u64;
+
+            if last_emit.elapsed() >= EMIT_INTERVAL {
+                let _ = app.emit("download:zip:progress", ZipProgress {
+                    id: id.clone(),
+                    bytes: bytes_done,
+                    total,
+                });
+                last_emit = Instant::now();
+            }
+        }
+        file.flush().await.map_err(|e| e.to_string())?;
+        Ok(bytes_done)
+    }.await;
+
+    match result {
+        Err(e) => {
+            let _ = tokio::fs::remove_file(&part_path).await;
+            Err(e)
+        }
+        Ok(bytes_done) => {
+            // Final emission so the frontend sees 100 % (or final MB count).
+            let _ = app.emit("download:zip:progress", ZipProgress {
+                id: id.clone(),
+                bytes: bytes_done,
+                total: Some(bytes_done),
+            });
+            tokio::fs::rename(&part_path, &dest_path)
+                .await
+                .map_err(|e| e.to_string())?;
+            Ok(dest_path)
+        }
+    }
+}
+
 #[derive(serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 struct HotCacheDownloadResult {
@@ -605,12 +1174,21 @@ async fn download_track_hot_cache(
     if !response.status().is_success() {
         return Err(format!("HTTP {}", response.status().as_u16()));
     }
-    let bytes = response.bytes().await.map_err(|e| e.to_string())?;
-    tokio::fs::write(&file_path, &bytes)
+
+    // Stream directly to a .part file; rename on success to avoid partial files.
+    let part_path = file_path.with_extension(format!("{suffix}.part"));
+    if let Err(e) = stream_to_file(response, &part_path).await {
+        let _ = tokio::fs::remove_file(&part_path).await;
+        return Err(e);
+    }
+    tokio::fs::rename(&part_path, &file_path)
         .await
         .map_err(|e| e.to_string())?;
 
-    let size = bytes.len() as u64;
+    let size = tokio::fs::metadata(&file_path)
+        .await
+        .map(|m| m.len())
+        .unwrap_or(0);
     Ok(HotCacheDownloadResult {
         path: path_str,
         size,
@@ -803,6 +1381,53 @@ fn stop_audio_engine(app: &tauri::AppHandle) {
     if let Some(sink) = cur.sink.take() { sink.stop(); }
 }
 
+/// Returns `true` if running under a tiling window manager (Hyprland, Sway, i3,
+/// bspwm, AwesomeWM, Openbox, etc.).  Detection is based on environment variables
+/// set by the compositor / DE.
+#[cfg(target_os = "linux")]
+fn is_tiling_wm() -> bool {
+    // Direct compositor signatures (most reliable).
+    let direct = [
+        "HYPRLAND_INSTANCE_SIGNATURE", // Hyprland
+        "SWAYSOCK",                     // Sway
+        "I3SOCK",                       // i3
+    ]
+    .iter()
+    .any(|&var| std::env::var_os(var).is_some());
+
+    if direct {
+        return true;
+    }
+
+    // Check XDG_CURRENT_DESKTOP for known tiling WMs.
+    if let Ok(desktop) = std::env::var("XDG_CURRENT_DESKTOP") {
+        let desktop = desktop.to_lowercase();
+        let tiling_wms = [
+            "hyprland", "sway", "i3", "bspwm", "awesome", "openbox",
+            "xmonad", "dwm", "qtile", "herbstluftwm", "leftwm",
+        ];
+        if tiling_wms.iter().any(|&wm| desktop.contains(wm)) {
+            return true;
+        }
+    }
+
+    false
+}
+
+/// Tauri command: lets the frontend know whether we're running under a tiling
+/// WM so it can decide whether to render the custom TitleBar component.
+#[tauri::command]
+fn is_tiling_wm_cmd() -> bool {
+    #[cfg(target_os = "linux")]
+    {
+        is_tiling_wm()
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        false
+    }
+}
+
 pub fn run() {
     let (audio_engine, _audio_thread) = audio::create_engine();
 
@@ -810,6 +1435,7 @@ pub fn run() {
         .manage(audio_engine)
         .manage(ShortcutMap::default())
         .manage(discord::DiscordState::new())
+        .manage(Arc::new(tokio::sync::Semaphore::new(MAX_DL_CONCURRENCY)) as DownloadSemaphore)
         .manage(TrayState::default())
         .plugin(tauri_plugin_process::init())
         .plugin(tauri_plugin_window_state::Builder::default().build())
@@ -826,6 +1452,18 @@ pub fn run() {
         }))
 
         .setup(|app| {
+            // ── Custom title bar on Linux ─────────────────────────────────
+            // Remove OS window decorations on all Linux so the React TitleBar
+            // can take over.  The frontend checks is_tiling_wm() to decide
+            // whether to actually render the TitleBar (hidden on tiling WMs).
+            #[cfg(target_os = "linux")]
+            {
+                use tauri::Manager;
+                if let Some(win) = app.get_webview_window("main") {
+                    let _ = win.set_decorations(false);
+                }
+            }
+
             // ── System tray ───────────────────────────────────────────────
             // Always build on startup; the frontend calls toggle_tray_icon(false)
             // immediately after load if the user has disabled the tray icon.
@@ -924,6 +1562,24 @@ pub fn run() {
                 app.manage(MprisControls::new(maybe_controls));
             }
 
+            // ── Windows Taskbar Thumbnail Toolbar ────────────────────────
+            #[cfg(target_os = "windows")]
+            {
+                use tauri::Manager;
+                if let Some(w) = app.get_webview_window("main") {
+                    if let Ok(hwnd) = w.hwnd() {
+                        taskbar_win::init(app.handle(), hwnd.0 as isize);
+                    }
+                }
+            }
+
+            // ── Audio device-change watcher ───────────────────────────────
+            {
+                use tauri::Manager;
+                let engine = app.state::<audio::AudioEngine>();
+                audio::start_device_watcher(&engine, app.handle().clone());
+            }
+
             Ok(())
         })
         .on_window_event(|window, event| {
@@ -951,6 +1607,8 @@ pub fn run() {
         .invoke_handler(tauri::generate_handler![
             greet,
             exit_app,
+            set_window_decorations,
+            is_tiling_wm_cmd,
             register_global_shortcut,
             unregister_global_shortcut,
             mpris_set_metadata,
@@ -980,6 +1638,8 @@ pub fn run() {
             search_radio_browser,
             get_top_radio_stations,
             fetch_url_bytes,
+            fetch_json_url,
+            fetch_icy_metadata,
             download_track_offline,
             delete_offline_track,
             get_offline_cache_size,
@@ -988,6 +1648,15 @@ pub fn run() {
             delete_hot_cache_track,
             purge_hot_cache,
             toggle_tray_icon,
+            check_dir_accessible,
+            download_zip,
+            check_arch_linux,
+            download_update,
+            open_folder,
+            get_embedded_lyrics,
+            fetch_netease_lyrics,
+            #[cfg(target_os = "windows")]
+            taskbar_win::update_taskbar_icon,
         ])
         .run(tauri::generate_context!())
         .expect("error while running Psysonic");

src-tauri/src/taskbar_win.rs

@@ -0,0 +1,276 @@
+//! Windows Taskbar Thumbnail Toolbar (ITaskbarList3::ThumbBarAddButtons).
+//!
+//! Adds Prev / Play-Pause / Next buttons to the taskbar thumbnail preview.
+//! Button clicks are intercepted via SetWindowSubclass and routed to the same
+//! `media:prev`, `media:play-pause`, `media:next` events as souvlaki / tray.
+
+use std::sync::atomic::{AtomicIsize, Ordering};
+
+use tauri::{AppHandle, Emitter};
+use windows::{
+    Win32::{
+        Foundation::{HWND, LPARAM, LRESULT, WPARAM},
+        System::Com::{
+            CoCreateInstance, CoInitializeEx, CLSCTX_INPROC_SERVER, COINIT_APARTMENTTHREADED,
+        },
+        UI::{
+            Shell::{
+                DefSubclassProc, ITaskbarList3, RemoveWindowSubclass, SetWindowSubclass,
+                TaskbarList, THUMBBUTTON, THUMBBUTTONFLAGS, THUMBBUTTONMASK, THBN_CLICKED,
+                THB_FLAGS, THB_ICON, THB_TOOLTIP,
+            },
+            WindowsAndMessaging::{
+                CreateIconFromResourceEx, DestroyIcon, HICON, LR_DEFAULTCOLOR,
+                WM_COMMAND, WM_NCDESTROY,
+            },
+        },
+    },
+};
+
+// ── Embedded ICO assets ──────────────────────────────────────────────────────
+
+static PREV_ICO:  &[u8] = include_bytes!("../icons/windows/prev.ico");
+static PLAY_ICO:  &[u8] = include_bytes!("../icons/windows/play.ico");
+static PAUSE_ICO: &[u8] = include_bytes!("../icons/windows/pause.ico");
+static NEXT_ICO:  &[u8] = include_bytes!("../icons/windows/next.ico");
+
+// Button IDs — arbitrary u32 values, must fit in WPARAM low-word.
+const BTN_PREV: u32 = 0xE001;
+const BTN_PLAY: u32 = 0xE002;
+const BTN_NEXT: u32 = 0xE003;
+
+// Unique subclass ID.
+const SUBCLASS_ID: usize = 0xC0DE_7A8B;
+
+// Raw pointers kept as atomics so `update_taskbar_icon` can reach the
+// COM object and icons without managed state.
+static TASKBAR_PTR: AtomicIsize = AtomicIsize::new(0);
+static HWND_VAL:    AtomicIsize = AtomicIsize::new(0);
+
+// All four HICONs stored for WM_NCDESTROY cleanup and play/pause swapping.
+static HICON_PREV:  AtomicIsize = AtomicIsize::new(0);
+static HICON_PLAY:  AtomicIsize = AtomicIsize::new(0);
+static HICON_PAUSE: AtomicIsize = AtomicIsize::new(0);
+static HICON_NEXT:  AtomicIsize = AtomicIsize::new(0);
+
+// ── ICO resource loader ──────────────────────────────────────────────────────
+
+/// Load the best-match image from a raw `.ico` file in memory and return an HICON.
+///
+/// Parses the ICO directory to pick the entry with the highest bit depth
+/// (32 bpp = true-colour + alpha), then passes the image bits directly to
+/// `CreateIconFromResourceEx`.
+///
+/// Note: `LookupIconIdFromDirectoryEx` operates on Win32 *resource* group-icon
+/// format (GRPICONDIR), not raw `.ico` files, so we parse the ICO header ourselves.
+unsafe fn load_icon_from_memory(bytes: &[u8]) -> HICON {
+    // ICO file layout:
+    //   ICONDIR        : reserved(2) + type(2) + count(2)
+    //   ICONDIRENTRY[] : width(1) height(1) color_count(1) reserved(1)
+    //                    planes(2) bit_count(2) bytes_in_res(4) image_offset(4)
+    if bytes.len() < 6 {
+        return HICON::default();
+    }
+    let count = u16::from_le_bytes([bytes[4], bytes[5]]) as usize;
+    if count == 0 || bytes.len() < 6 + count * 16 {
+        return HICON::default();
+    }
+
+    // Pick the entry with the highest bit depth; 32 bpp carries alpha.
+    let mut best_idx = 0usize;
+    let mut best_bpp = 0u16;
+    for i in 0..count {
+        let base = 6 + i * 16;
+        let bpp = u16::from_le_bytes([bytes[base + 6], bytes[base + 7]]);
+        if bpp >= best_bpp {
+            best_bpp = bpp;
+            best_idx = i;
+        }
+    }
+
+    let entry      = &bytes[6 + best_idx * 16..];
+    let img_size   = u32::from_le_bytes(entry[8..12].try_into().unwrap_or([0; 4]));
+    let img_offset = u32::from_le_bytes(entry[12..16].try_into().unwrap_or([0; 4])) as usize;
+
+    if img_size == 0 || img_offset + img_size as usize > bytes.len() {
+        return HICON::default();
+    }
+
+    CreateIconFromResourceEx(
+        &bytes[img_offset..img_offset + img_size as usize],
+        true,        // fIcon = TRUE
+        0x0003_0000, // dwVer = 3.0 (required by the API)
+        0, 0,        // cxDesired / cyDesired — 0 lets the system choose
+        LR_DEFAULTCOLOR,
+    )
+    .unwrap_or_default()
+}
+
+// ── Button descriptors ───────────────────────────────────────────────────────
+
+fn copy_tip(dest: &mut [u16], src: &str) {
+    let wide: Vec<u16> = src.encode_utf16().chain(std::iter::once(0)).collect();
+    let len = wide.len().min(dest.len());
+    dest[..len].copy_from_slice(&wide[..len]);
+}
+
+unsafe fn make_buttons(
+    h_prev: HICON,
+    h_play: HICON,
+    h_next: HICON,
+) -> [THUMBBUTTON; 3] {
+    let mask  = THUMBBUTTONMASK(THB_ICON.0 | THB_TOOLTIP.0 | THB_FLAGS.0);
+    let flags = THUMBBUTTONFLAGS(0); // THBF_ENABLED
+
+    let mut prev = THUMBBUTTON::default();
+    prev.dwMask  = mask; prev.iId = BTN_PREV;
+    prev.hIcon   = h_prev; prev.dwFlags = flags;
+    copy_tip(&mut prev.szTip, "Previous");
+
+    let mut play = THUMBBUTTON::default();
+    play.dwMask  = mask; play.iId = BTN_PLAY;
+    play.hIcon   = h_play; play.dwFlags = flags;
+    copy_tip(&mut play.szTip, "Play");
+
+    let mut next = THUMBBUTTON::default();
+    next.dwMask  = mask; next.iId = BTN_NEXT;
+    next.hIcon   = h_next; next.dwFlags = flags;
+    copy_tip(&mut next.szTip, "Next");
+
+    [prev, play, next]
+}
+
+// ── WndProc subclass ─────────────────────────────────────────────────────────
+
+struct SubclassData {
+    app: AppHandle,
+}
+
+unsafe extern "system" fn subclass_proc(
+    hwnd:   HWND,
+    msg:    u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+    _uid:   usize,
+    data:   usize,
+) -> LRESULT {
+    if msg == WM_COMMAND {
+        let hi = (wparam.0 >> 16) as u32;
+        let lo = (wparam.0 & 0xFFFF) as u32;
+        if hi == THBN_CLICKED as u32 {
+            if data != 0 {
+                let state = &*(data as *const SubclassData);
+                let _ = match lo {
+                    x if x == BTN_PREV => state.app.emit("media:prev", ()),
+                    x if x == BTN_PLAY => state.app.emit("media:play-pause", ()),
+                    x if x == BTN_NEXT => state.app.emit("media:next", ()),
+                    _ => Ok(()),
+                };
+            }
+            return LRESULT(0);
+        }
+    }
+
+    if msg == WM_NCDESTROY {
+        let _ = RemoveWindowSubclass(hwnd, Some(subclass_proc), SUBCLASS_ID);
+        if data != 0 {
+            drop(Box::from_raw(data as *mut SubclassData));
+        }
+        let raw = TASKBAR_PTR.swap(0, Ordering::SeqCst);
+        if raw != 0 {
+            drop(Box::from_raw(raw as *mut ITaskbarList3));
+        }
+        HWND_VAL.store(0, Ordering::SeqCst);
+        // Destroy all stored HICONs.
+        for cell in [&HICON_PREV, &HICON_PLAY, &HICON_PAUSE, &HICON_NEXT] {
+            let h = cell.swap(0, Ordering::SeqCst);
+            if h != 0 { let _ = DestroyIcon(HICON(h as *mut _)); }
+        }
+    }
+
+    DefSubclassProc(hwnd, msg, wparam, lparam)
+}
+
+// ── Public init ──────────────────────────────────────────────────────────────
+
+pub fn init(app: &AppHandle, hwnd_raw: isize) {
+    unsafe {
+        let _ = CoInitializeEx(None, COINIT_APARTMENTTHREADED);
+
+        let hwnd = HWND(hwnd_raw as *mut _);
+
+        let taskbar: ITaskbarList3 = match CoCreateInstance(
+            &TaskbarList, None, CLSCTX_INPROC_SERVER,
+        ) {
+            Ok(t)  => t,
+            Err(e) => { eprintln!("[psysonic] taskbar: CoCreateInstance failed: {e}"); return; }
+        };
+
+        if let Err(e) = taskbar.HrInit() {
+            eprintln!("[psysonic] taskbar: HrInit failed: {e}");
+            return;
+        }
+
+        let h_prev  = load_icon_from_memory(PREV_ICO);
+        let h_play  = load_icon_from_memory(PLAY_ICO);
+        let h_pause = load_icon_from_memory(PAUSE_ICO);
+        let h_next  = load_icon_from_memory(NEXT_ICO);
+
+        // Store all HICONs for cleanup and play/pause swapping.
+        HICON_PREV .store(h_prev .0 as isize, Ordering::SeqCst);
+        HICON_PLAY .store(h_play .0 as isize, Ordering::SeqCst);
+        HICON_PAUSE.store(h_pause.0 as isize, Ordering::SeqCst);
+        HICON_NEXT .store(h_next .0 as isize, Ordering::SeqCst);
+
+        let mut buttons = make_buttons(h_prev, h_play, h_next);
+        if let Err(e) = taskbar.ThumbBarAddButtons(hwnd, &mut buttons) {
+            eprintln!("[psysonic] taskbar: ThumbBarAddButtons failed: {e}");
+            return;
+        }
+
+        let raw = Box::into_raw(Box::new(taskbar));
+        TASKBAR_PTR.store(raw as isize, Ordering::SeqCst);
+        HWND_VAL   .store(hwnd_raw,     Ordering::SeqCst);
+
+        let data = Box::into_raw(Box::new(SubclassData { app: app.clone() }));
+        if !SetWindowSubclass(hwnd, Some(subclass_proc), SUBCLASS_ID, data as usize).as_bool() {
+            eprintln!("[psysonic] taskbar: SetWindowSubclass failed");
+            drop(Box::from_raw(data));
+        }
+    }
+}
+
+// ── Tauri command ────────────────────────────────────────────────────────────
+
+#[tauri::command]
+pub fn update_taskbar_icon(is_playing: bool) {
+    let taskbar_raw = TASKBAR_PTR.load(Ordering::SeqCst);
+    let hwnd_raw    = HWND_VAL   .load(Ordering::SeqCst);
+    if taskbar_raw == 0 || hwnd_raw == 0 { return; }
+
+    let icon_raw = if is_playing {
+        HICON_PAUSE.load(Ordering::SeqCst)
+    } else {
+        HICON_PLAY.load(Ordering::SeqCst)
+    };
+    if icon_raw == 0 { return; }
+
+    unsafe {
+        let taskbar = &*(taskbar_raw as *const ITaskbarList3);
+        let hwnd    = HWND(hwnd_raw as *mut _);
+
+        let mut btn = THUMBBUTTON::default();
+        btn.dwMask  = THUMBBUTTONMASK(THB_ICON.0 | THB_TOOLTIP.0 | THB_FLAGS.0);
+        btn.iId     = BTN_PLAY;
+        btn.hIcon   = HICON(icon_raw as *mut _);
+        btn.dwFlags = THUMBBUTTONFLAGS(0);
+        copy_tip(&mut btn.szTip, if is_playing { "Pause" } else { "Play" });
+
+        let mut btns = [btn];
+        if let Err(e) = taskbar.ThumbBarUpdateButtons(hwnd, &mut btns) {
+            #[cfg(debug_assertions)]
+            eprintln!("[psysonic] taskbar: ThumbBarUpdateButtons failed: {e}");
+            let _ = e;
+        }
+    }
+}

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Psysonic",
-  "version": "1.34.2",
+  "version": "1.34.8",
   "identifier": "dev.psysonic.player",
   "build": {
     "beforeDevCommand": "npm run dev",

src/App.tsx

@@ -26,6 +26,7 @@ import Login from './pages/Login';
 import AlbumDetail from './pages/AlbumDetail';
 import LabelAlbums from './pages/LabelAlbums';
 import Statistics from './pages/Statistics';
+import MostPlayed from './pages/MostPlayed';
 import Help from './pages/Help';
 import RandomAlbums from './pages/RandomAlbums';
 import SearchResults from './pages/SearchResults';
@@ -33,6 +34,7 @@ import AdvancedSearch from './pages/AdvancedSearch';
 import Playlists from './pages/Playlists';
 import PlaylistDetail from './pages/PlaylistDetail';
 import InternetRadio from './pages/InternetRadio';
+import FolderBrowser from './pages/FolderBrowser';
 import NowPlayingPage from './pages/NowPlaying';
 import FullscreenPlayer from './components/FullscreenPlayer';
 import ContextMenu from './components/ContextMenu';
@@ -50,18 +52,23 @@ import GenreDetail from './pages/GenreDetail';
 import ExportPickerModal from './components/ExportPickerModal';
 import ChangelogModal from './components/ChangelogModal';
 import AppUpdater from './components/AppUpdater';
+import TitleBar from './components/TitleBar';
+import { IS_LINUX } from './utils/platform';
 import { version } from '../package.json';
 import { useConnectionStatus } from './hooks/useConnectionStatus';
 import { useAuthStore } from './store/authStore';
-import { getMusicFolders } from './api/subsonic';
+import { getMusicFolders, probeEntityRatingSupport } from './api/subsonic';
 import { useOfflineStore } from './store/offlineStore';
 import { initHotCachePrefetch } from './hotCachePrefetch';
 import { usePlayerStore, initAudioListeners } from './store/playerStore';
 import { useThemeStore } from './store/themeStore';
+import { useThemeScheduler } from './hooks/useThemeScheduler';
 import { useFontStore } from './store/fontStore';
 import { useEqStore } from './store/eqStore';
 import { useKeybindingsStore } from './store/keybindingsStore';
 import { useGlobalShortcutsStore } from './store/globalShortcutsStore';
+import { useZipDownloadStore } from './store/zipDownloadStore';
+import ZipDownloadOverlay from './components/ZipDownloadOverlay';
 
 function RequireAuth({ children }: { children: React.ReactNode }) {
   const { isLoggedIn, servers, activeServerId } = useAuthStore();
@@ -72,6 +79,27 @@ function RequireAuth({ children }: { children: React.ReactNode }) {
 function AppShell() {
   const { t } = useTranslation();
   const isMobile = useIsMobile();
+  const [isWindowFullscreen, setIsWindowFullscreen] = useState(false);
+  const [isTilingWm, setIsTilingWm] = useState(false);
+
+  useEffect(() => {
+    if (!IS_LINUX) return;
+    invoke<boolean>('is_tiling_wm_cmd').then(setIsTilingWm).catch(() => {});
+  }, []);
+
+  useEffect(() => {
+    const win = getCurrentWindow();
+    // Check initial state (e.g. app launched maximised / already fullscreen).
+    win.isFullscreen().then(setIsWindowFullscreen).catch(() => {});
+    let unlisten: (() => void) | undefined;
+    // onResized fires on every size change, including fullscreen enter/exit on
+    // all platforms.  We re-query isFullscreen() rather than inferring from
+    // the size so the flag is always accurate regardless of platform quirks.
+    win.onResized(() => {
+      win.isFullscreen().then(setIsWindowFullscreen).catch(() => {});
+    }).then(u => { unlisten = u; });
+    return () => { unlisten?.(); };
+  }, []);
   const isFullscreenOpen = usePlayerStore(s => s.isFullscreenOpen);
   const toggleFullscreen = usePlayerStore(s => s.toggleFullscreen);
   const isQueueVisible = usePlayerStore(s => s.isQueueVisible);
@@ -86,24 +114,47 @@ function AppShell() {
   const isLoggedIn = useAuthStore(s => s.isLoggedIn);
   const activeServerId = useAuthStore(s => s.activeServerId);
   const setMusicFolders = useAuthStore(s => s.setMusicFolders);
+  const useCustomTitlebar = useAuthStore(s => s.useCustomTitlebar);
+  const setEntityRatingSupport = useAuthStore(s => s.setEntityRatingSupport);
   const offlineAlbums = useOfflineStore(s => s.albums);
   const hasOfflineContent = Object.values(offlineAlbums).some(a => a.serverId === serverId);
 
+  // Sync custom titlebar preference with native decorations on Linux
+  // On tiling WMs decorations are always off (no native title bar to replace).
+  useEffect(() => {
+    if (!IS_LINUX) return;
+    const enabled = isTilingWm ? false : !useCustomTitlebar;
+    invoke('set_window_decorations', { enabled }).catch(() => {});
+  }, [useCustomTitlebar, isTilingWm]);
+
   useEffect(() => {
     if (!isLoggedIn || !activeServerId) return;
+    const serverAtStart = activeServerId;
     let cancelled = false;
     (async () => {
+      const stillThisServer = () => !cancelled && useAuthStore.getState().activeServerId === serverAtStart;
       try {
         const folders = await getMusicFolders();
-        if (!cancelled) setMusicFolders(folders);
+        if (stillThisServer()) setMusicFolders(folders);
       } catch {
-        if (!cancelled) setMusicFolders([]);
+        if (stillThisServer()) setMusicFolders([]);
+      }
+      try {
+        const level = await probeEntityRatingSupport();
+        if (stillThisServer()) setEntityRatingSupport(serverAtStart, level);
+      } catch {
+        if (stillThisServer()) setEntityRatingSupport(serverAtStart, 'track_only');
       }
     })();
     return () => {
       cancelled = true;
     };
-  }, [isLoggedIn, activeServerId, setMusicFolders]);
+  }, [isLoggedIn, activeServerId, setMusicFolders, setEntityRatingSupport]);
+
+  // Reset scroll position on route change
+  useEffect(() => {
+    document.querySelector('.content-body')?.scrollTo({ top: 0 });
+  }, [location.pathname]);
 
   // Auto-navigate to offline library when no connection but cached content exists
   const prevConnStatus = useRef(connStatus);
@@ -247,16 +298,19 @@ function AppShell() {
   const isMobilePlayer = isMobile && location.pathname === '/now-playing';
 
   return (
-    <div 
+    <div
       className="app-shell"
       data-mobile={isMobile || undefined}
       data-mobile-player={isMobilePlayer || undefined}
+      data-titlebar={(IS_LINUX && useCustomTitlebar && !isWindowFullscreen && !isTilingWm) || undefined}
+      data-fullscreen={isWindowFullscreen || undefined}
       style={{
         '--sidebar-width': isMobile ? '0px' : (isSidebarCollapsed ? '72px' : 'clamp(200px, 15vw, 220px)'),
         '--queue-width': isMobile ? '0px' : (isQueueVisible ? `${queueWidth}px` : '0px')
       } as React.CSSProperties}
       onContextMenu={e => e.preventDefault()}
     >
+      {IS_LINUX && useCustomTitlebar && !isWindowFullscreen && !isTilingWm && <TitleBar />}
       {!isMobile && (
         <Sidebar
           isCollapsed={isSidebarCollapsed}
@@ -304,6 +358,7 @@ function AppShell() {
             <Route path="/search" element={<SearchResults />} />
             <Route path="/search/advanced" element={<AdvancedSearch />} />
             <Route path="/statistics" element={<Statistics />} />
+            <Route path="/most-played" element={<MostPlayed />} />
             <Route path="/now-playing" element={isMobile ? <MobilePlayerView /> : <NowPlayingPage />} />
             <Route path="/settings" element={<Settings />} />
             <Route path="/help" element={<Help />} />
@@ -313,6 +368,7 @@ function AppShell() {
             <Route path="/playlists" element={<Playlists />} />
             <Route path="/playlists/:id" element={<PlaylistDetail />} />
             <Route path="/radio" element={<InternetRadio />} />
+            <Route path="/folders" element={<FolderBrowser />} />
           </Routes>
         </div>
       </main>
@@ -348,6 +404,37 @@ function TauriEventBridge() {
   const next = usePlayerStore(s => s.next);
   const previous = usePlayerStore(s => s.previous);
 
+  // ZIP download progress events from Rust
+  useEffect(() => {
+    let unlisten: (() => void) | undefined;
+    listen<{ id: string; bytes: number; total: number | null }>('download:zip:progress', e => {
+      useZipDownloadStore.getState().updateProgress(e.payload.id, e.payload.bytes, e.payload.total);
+    }).then(u => { unlisten = u; });
+    return () => { unlisten?.(); };
+  }, []);
+
+  // Audio output device changed (Bluetooth headphones, USB DAC, etc.)
+  // The Rust device-watcher has already reopened the stream on the new device
+  // and dropped the old Sink, so we just need to restart playback.
+  useEffect(() => {
+    let unlisten: (() => void) | undefined;
+    listen('audio:device-changed', () => {
+      const { currentTrack, currentTime, isPlaying, playTrack, resetAudioPause } = usePlayerStore.getState();
+      if (!currentTrack) return;
+      if (isPlaying) {
+        const pos = currentTime;
+        const dur = currentTrack.duration || 1;
+        playTrack(currentTrack);
+        setTimeout(() => usePlayerStore.getState().seek(pos / dur), 600);
+      } else {
+        // Paused: clear warm-pause flag so the next resume uses the cold path
+        // (audio_play + seek) which creates a new Sink on the new device.
+        resetAudioPause();
+      }
+    }).then(u => { unlisten = u; });
+    return () => { unlisten?.(); };
+  }, []);
+
   // Sync tray-icon visibility with the user's stored setting.
   // Runs once on mount (initial sync) and again whenever the setting changes.
   const showTrayIcon = useAuthStore(s => s.showTrayIcon);
@@ -466,18 +553,33 @@ function TauriEventBridge() {
 }
 
 export default function App() {
-  const theme = useThemeStore(s => s.theme);
+  useThemeStore(s => s.theme); // keep subscription so re-render on manual change
+  const effectiveTheme = useThemeScheduler();
   const font = useFontStore(s => s.font);
+  const uiScale = useFontStore(s => s.uiScale);
+  const setUiScale = useFontStore(s => s.setUiScale);
   const [exportPickerOpen, setExportPickerOpen] = useState(false);
 
   useEffect(() => {
-    document.documentElement.setAttribute('data-theme', theme);
-  }, [theme]);
+    document.documentElement.setAttribute('data-theme', effectiveTheme);
+  }, [effectiveTheme]);
 
   useEffect(() => {
     document.documentElement.setAttribute('data-font', font);
   }, [font]);
 
+  // TODO(ui-scale): UI scaling is disabled pending a cross-platform rework.
+  // Reset any stored non-100% value so users aren't stuck at a broken scale.
+  // When re-enabling: remove this effect AND re-enable the slider in Settings.tsx.
+  useEffect(() => {
+    if (uiScale !== 1.0) setUiScale(1.0);
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  useEffect(() => {
+    document.documentElement.style.zoom = String(uiScale);
+  }, [uiScale]);
+
   useEffect(() => {
     return initAudioListeners();
   }, []);
@@ -554,6 +656,7 @@ export default function App() {
         />
       </Routes>
       {exportPickerOpen && <ExportPickerModal onConfirm={handleExport} onClose={() => setExportPickerOpen(false)} />}
+      <ZipDownloadOverlay />
     </BrowserRouter>
   );
 }

src/api/azuracast.ts

@@ -0,0 +1,111 @@
+import { invoke } from '@tauri-apps/api/core';
+
+// ─── AzuraCast API types ──────────────────────────────────────────────────────
+
+export interface AzuraCastSong {
+  artist: string;
+  title: string;
+  album: string;
+  art?: string;
+  text?: string; // "Artist - Title" combined
+}
+
+export interface AzuraCastNowPlayingTrack {
+  song: AzuraCastSong;
+  duration: number;  // seconds
+  elapsed: number;   // seconds played so far
+  remaining: number; // seconds remaining
+  played_at?: number;
+}
+
+export interface AzuraCastListeners {
+  current: number;
+  unique?: number;
+  total?: number;
+}
+
+export interface AzuraCastNowPlaying {
+  now_playing: AzuraCastNowPlayingTrack;
+  playing_next?: { song: AzuraCastSong } | null;
+  song_history: Array<{ song: AzuraCastSong; played_at?: number }>;
+  listeners: AzuraCastListeners;
+  station?: { name: string; shortcode: string };
+}
+
+// ─── Detection helpers ────────────────────────────────────────────────────────
+
+/**
+ * Try to derive an AzuraCast NowPlaying API URL from a stream URL.
+ *
+ * AzuraCast stream URLs follow the pattern:
+ *   https://<host>/listen/<shortcode>/<bitrate>.<ext>
+ *
+ * Returns the candidate API URL or `null` if the pattern doesn't match.
+ */
+export function guessAzuraCastApiUrl(streamUrl: string): string | null {
+  try {
+    const u = new URL(streamUrl);
+    const parts = u.pathname.split('/').filter(Boolean);
+    // Expect: ['listen', '<shortcode>', '<file>']
+    if (parts.length >= 2 && parts[0] === 'listen') {
+      const shortcode = parts[1];
+      return `${u.origin}/api/nowplaying/${shortcode}`;
+    }
+  } catch {
+    // ignore invalid URLs
+  }
+  return null;
+}
+
+/**
+ * Check whether a homepage URL itself looks like an AzuraCast NowPlaying
+ * API endpoint and return the canonical URL to use.
+ *
+ * Accepts:
+ *   - https://<host>/api/nowplaying                  → all stations, we use as-is
+ *   - https://<host>/api/nowplaying/<shortcode>      → single station, use as-is
+ */
+export function normaliseAzuraCastHomepageUrl(homepageUrl: string): string | null {
+  try {
+    const u = new URL(homepageUrl);
+    if (/^\/api\/nowplaying(\/[^/]+)?$/.test(u.pathname)) {
+      return homepageUrl;
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+/**
+ * Fetch AzuraCast NowPlaying data from the given API URL (bypasses CORS via
+ * the Rust backend).  Returns `null` if the request fails or the response
+ * does not look like a valid AzuraCast payload.
+ *
+ * When the API URL points to the `/api/nowplaying` (array) endpoint, the
+ * first item in the array is returned.  Otherwise the single-object form is
+ * used directly.
+ */
+export async function fetchAzuraCastNowPlaying(apiUrl: string): Promise<AzuraCastNowPlaying | null> {
+  try {
+    const raw: string = await invoke('fetch_json_url', { url: apiUrl });
+    const parsed = JSON.parse(raw);
+
+    // If the response is an array (all-stations endpoint), take the first item.
+    const obj: unknown = Array.isArray(parsed) ? parsed[0] : parsed;
+    if (!obj || typeof obj !== 'object') return null;
+
+    const np = obj as Record<string, unknown>;
+    // Minimal validation: must have `now_playing` with a `song` inside.
+    if (
+      np.now_playing &&
+      typeof np.now_playing === 'object' &&
+      (np.now_playing as Record<string, unknown>).song
+    ) {
+      return np as unknown as AzuraCastNowPlaying;
+    }
+  } catch {
+    // Network error, JSON parse error, etc.
+  }
+  return null;
+}

src/api/lrclib.ts

@@ -36,7 +36,9 @@ export async function fetchLyrics(
 export function parseLrc(lrc: string): LrcLine[] {
   const lines: LrcLine[] = [];
   for (const line of lrc.split('\n')) {
-    const match = line.match(/^\[(\d+):(\d+\.\d+)\](.*)/);
+    // \d+(?:\.\d*)? — decimal part is optional so [mm:ss] (no fraction) also matches.
+    // parseFloat handles all forms: "15", "15.", "15.3", "15.32" correctly.
+    const match = line.match(/^\[(\d+):(\d+(?:\.\d*)?)\](.*)/);
     if (!match) continue;
     const mins = parseInt(match[1], 10);
     const secs = parseFloat(match[2]);

src/api/netease.ts

@@ -0,0 +1,10 @@
+import { invoke } from '@tauri-apps/api/core';
+
+/** Fetches a synced LRC string from Netease Cloud Music via Rust proxy. Returns null if not found. */
+export async function fetchNeteaselyrics(artist: string, title: string): Promise<string | null> {
+  try {
+    return await invoke<string | null>('fetch_netease_lyrics', { artist, title });
+  } catch {
+    return null;
+  }
+}

src/api/subsonic.ts

@@ -3,6 +3,11 @@ import md5 from 'md5';
 import { invoke } from '@tauri-apps/api/core';
 import { useAuthStore } from '../store/authStore';
 import { version } from '../../package.json';
+import {
+  isNavidromeAudiomuseSoftwareEligible,
+  type InstantMixProbeResult,
+  type SubsonicServerIdentity,
+} from '../utils/subsonicServerIdentity';
 
 // ─── Secure random salt ────────────────────────────────────────
 function secureRandomSalt(): string {
@@ -58,11 +63,21 @@ export interface SubsonicAlbum {
   coverArt?: string;
   songCount: number;
   duration: number;
+  playCount?: number;
   year?: number;
   genre?: string;
   starred?: string;
   recordLabel?: string;
   created?: string;
+  /** Present on some servers (e.g. OpenSubsonic) for album-level rating. */
+  userRating?: number;
+}
+
+/** OpenSubsonic `artists` / `albumArtists` entries on a child song (may include `userRating`). */
+export interface SubsonicOpenArtistRef {
+  id?: string;
+  name?: string;
+  userRating?: number;
 }
 
 export interface SubsonicSong {
@@ -78,6 +93,11 @@ export interface SubsonicSong {
   coverArt?: string;
   year?: number;
   userRating?: number;
+  /** Some OpenSubsonic responses attach parent ratings on child songs. */
+  albumUserRating?: number;
+  artistUserRating?: number;
+  artists?: SubsonicOpenArtistRef[];
+  albumArtists?: SubsonicOpenArtistRef[];
   // Audio technical info
   bitRate?: number;
   suffix?: string;
@@ -140,6 +160,8 @@ export interface SubsonicArtist {
   albumCount?: number;
   coverArt?: string;
   starred?: string;
+  /** Present on some servers (e.g. OpenSubsonic) for artist-level rating. */
+  userRating?: number;
 }
 
 export interface SubsonicGenre {
@@ -164,6 +186,68 @@ export interface SubsonicArtistInfo {
 }
 
 // ─── API Methods ──────────────────────────────────────────────
+export interface SubsonicDirectoryEntry {
+  id: string;
+  parent?: string;
+  title: string;
+  isDir: boolean;
+  album?: string;
+  artist?: string;
+  albumId?: string;
+  artistId?: string;
+  coverArt?: string;
+  duration?: number;
+  track?: number;
+  year?: number;
+  bitRate?: number;
+  suffix?: string;
+  size?: number;
+  genre?: string;
+  starred?: string;
+  userRating?: number;
+}
+
+export interface SubsonicDirectory {
+  id: string;
+  parent?: string;
+  name: string;
+  child: SubsonicDirectoryEntry[];
+}
+
+export async function getMusicDirectory(id: string): Promise<SubsonicDirectory> {
+  const data = await api<{ directory: { id: string; parent?: string; name: string; child?: SubsonicDirectoryEntry | SubsonicDirectoryEntry[] } }>(
+    'getMusicDirectory.view',
+    { id },
+  );
+  const dir = data.directory;
+  const raw = dir.child;
+  const child: SubsonicDirectoryEntry[] = !raw ? [] : Array.isArray(raw) ? raw : [raw];
+  return { id: dir.id, parent: dir.parent, name: dir.name, child };
+}
+
+/** Returns the top-level artist/directory entries for a music folder root.
+ *  Music folder IDs from getMusicFolders() are NOT valid getMusicDirectory IDs —
+ *  use getIndexes.view with musicFolderId instead. */
+export async function getMusicIndexes(musicFolderId: string): Promise<SubsonicDirectoryEntry[]> {
+  type IndexArtist = { id: string; name: string; coverArt?: string };
+  type IndexEntry  = { name: string; artist?: IndexArtist | IndexArtist[] };
+  const data = await api<{ indexes: { index?: IndexEntry | IndexEntry[] } }>(
+    'getIndexes.view',
+    { musicFolderId },
+  );
+  const raw = data.indexes?.index;
+  if (!raw) return [];
+  const indices = Array.isArray(raw) ? raw : [raw];
+  const entries: SubsonicDirectoryEntry[] = [];
+  for (const idx of indices) {
+    const artists = idx.artist ? (Array.isArray(idx.artist) ? idx.artist : [idx.artist]) : [];
+    for (const a of artists) {
+      entries.push({ id: a.id, title: a.name, isDir: true, coverArt: a.coverArt });
+    }
+  }
+  return entries;
+}
+
 export async function getMusicFolders(): Promise<SubsonicMusicFolder[]> {
   const data = await api<{ musicFolders: { musicFolder: SubsonicMusicFolder | SubsonicMusicFolder[] } }>(
     'getMusicFolders.view',
@@ -186,8 +270,14 @@ export async function ping(): Promise<boolean> {
   }
 }
 
+export type PingWithCredentialsResult = SubsonicServerIdentity & { ok: boolean };
+
 /** Test a connection with explicit credentials — does NOT depend on store state. */
-export async function pingWithCredentials(serverUrl: string, username: string, password: string): Promise<boolean> {
+export async function pingWithCredentials(
+  serverUrl: string,
+  username: string,
+  password: string,
+): Promise<PingWithCredentialsResult> {
   try {
     const base = serverUrl.startsWith('http') ? serverUrl.replace(/\/$/, '') : `http://${serverUrl.replace(/\/$/, '')}`;
     const salt = secureRandomSalt();
@@ -198,12 +288,108 @@ export async function pingWithCredentials(serverUrl: string, username: string, p
       timeout: 15000,
     });
     const data = resp.data?.['subsonic-response'];
-    return data?.status === 'ok';
+    const ok = data?.status === 'ok';
+    return {
+      ok,
+      type: typeof data?.type === 'string' ? data.type : undefined,
+      serverVersion: typeof data?.serverVersion === 'string' ? data.serverVersion : undefined,
+      openSubsonic: data?.openSubsonic === true,
+    };
   } catch {
-    return false;
+    return { ok: false };
   }
 }
 
+function restBaseFromUrl(serverUrl: string): string {
+  const base = serverUrl.startsWith('http') ? serverUrl.replace(/\/$/, '') : `http://${serverUrl.replace(/\/$/, '')}`;
+  return `${base}/rest`;
+}
+
+async function apiWithCredentials<T>(
+  serverUrl: string,
+  username: string,
+  password: string,
+  endpoint: string,
+  extra: Record<string, unknown> = {},
+  timeout = 15000,
+): Promise<T> {
+  const params = { ...getAuthParams(username, password), ...extra };
+  const resp = await axios.get(`${restBaseFromUrl(serverUrl)}/${endpoint}`, {
+    params,
+    paramsSerializer: { indexes: null },
+    timeout,
+  });
+  const data = resp.data?.['subsonic-response'];
+  if (!data) throw new Error('Invalid response from server (possibly not a Subsonic server)');
+  if (data.status !== 'ok') throw new Error(data.error?.message ?? 'Subsonic API error');
+  return data as T;
+}
+
+const INSTANT_MIX_PROBE_RANDOM_SIZE = 8;
+const INSTANT_MIX_PROBE_SIMILAR_COUNT = 12;
+const INSTANT_MIX_PROBE_MAX_TRACKS = 4;
+
+/**
+ * Probes whether `getSimilarSongs` returns any tracks (Instant Mix / Navidrome agent chain).
+ * Does not pass `musicFolderId` — probes the whole library as seen by the account.
+ * Note: if `ND_AGENTS` includes Last.fm, a positive result does not prove AudioMuse alone.
+ */
+export async function probeInstantMixWithCredentials(
+  serverUrl: string,
+  username: string,
+  password: string,
+): Promise<InstantMixProbeResult> {
+  try {
+    const data = await apiWithCredentials<{ randomSongs: { song: SubsonicSong | SubsonicSong[] } }>(
+      serverUrl,
+      username,
+      password,
+      'getRandomSongs.view',
+      { size: INSTANT_MIX_PROBE_RANDOM_SIZE, _t: Date.now() },
+      12000,
+    );
+    const raw = data.randomSongs?.song;
+    const songs: SubsonicSong[] = !raw ? [] : Array.isArray(raw) ? raw : [raw];
+    if (songs.length === 0) return 'skipped';
+
+    let anyError = false;
+    for (const song of songs.slice(0, INSTANT_MIX_PROBE_MAX_TRACKS)) {
+      try {
+        const simData = await apiWithCredentials<{ similarSongs: { song: SubsonicSong | SubsonicSong[] } }>(
+          serverUrl,
+          username,
+          password,
+          'getSimilarSongs.view',
+          { id: song.id, count: INSTANT_MIX_PROBE_SIMILAR_COUNT },
+          12000,
+        );
+        const sRaw = simData.similarSongs?.song;
+        const list: SubsonicSong[] = !sRaw ? [] : Array.isArray(sRaw) ? sRaw : [sRaw];
+        if (list.some(s => s.id !== song.id)) return 'ok';
+      } catch {
+        anyError = true;
+      }
+    }
+    return anyError ? 'error' : 'empty';
+  } catch {
+    return 'error';
+  }
+}
+
+/** After a successful ping, probe Instant Mix in the background (Navidrome ≥ 0.60 only). */
+export function scheduleInstantMixProbeForServer(
+  serverId: string,
+  serverUrl: string,
+  username: string,
+  password: string,
+  identity: SubsonicServerIdentity,
+): void {
+  if (!isNavidromeAudiomuseSoftwareEligible(identity)) return;
+  void probeInstantMixWithCredentials(serverUrl, username, password).then(result =>
+    useAuthStore.getState().setInstantMixProbe(serverId, result),
+  );
+}
+
 export async function getRandomAlbums(size = 6): Promise<SubsonicAlbum[]> {
   const data = await api<{ albumList2: { album: SubsonicAlbum[] } }>('getAlbumList2.view', {
     type: 'random',
@@ -230,6 +416,68 @@ export async function getAlbumList(
   return data.albumList2?.album ?? [];
 }
 
+/**
+ * Navidrome (and some servers) ignore `musicFolderId` on getSimilarSongs / getSimilarSongs2 / getTopSongs,
+ * so similar tracks can leak from other libraries. When the user scoped to one folder, we keep a set of
+ * album ids in that scope (paginated getAlbumList2) and drop songs whose albumId is not in the set.
+ */
+let scopedLibraryAlbumIdCache: {
+  serverId: string;
+  folderId: string;
+  filterVersion: number;
+  ids: Set<string>;
+} | null = null;
+
+async function albumIdsInActiveLibraryScope(): Promise<Set<string> | null> {
+  const { activeServerId, musicLibraryFilterByServer, musicLibraryFilterVersion } = useAuthStore.getState();
+  if (!activeServerId) return null;
+  const folder = musicLibraryFilterByServer[activeServerId];
+  if (folder === undefined || folder === 'all') {
+    scopedLibraryAlbumIdCache = null;
+    return null;
+  }
+  const hit = scopedLibraryAlbumIdCache;
+  if (
+    hit &&
+    hit.serverId === activeServerId &&
+    hit.folderId === folder &&
+    hit.filterVersion === musicLibraryFilterVersion
+  ) {
+    return hit.ids;
+  }
+  const ids = new Set<string>();
+  const pageSize = 500;
+  let offset = 0;
+  for (;;) {
+    const albums = await getAlbumList('alphabeticalByName', pageSize, offset);
+    for (const a of albums) ids.add(a.id);
+    if (albums.length < pageSize) break;
+    offset += pageSize;
+    if (offset > 500_000) break;
+  }
+  scopedLibraryAlbumIdCache = {
+    serverId: activeServerId,
+    folderId: folder,
+    filterVersion: musicLibraryFilterVersion,
+    ids,
+  };
+  return ids;
+}
+
+export async function filterSongsToActiveLibrary(songs: SubsonicSong[]): Promise<SubsonicSong[]> {
+  const allowed = await albumIdsInActiveLibraryScope();
+  if (!allowed || allowed.size === 0) return songs;
+  return songs.filter(s => s.albumId && allowed.has(s.albumId));
+}
+
+/** When scoped to one library, ask the server for more similar tracks — many will be filtered out client-side. */
+function similarSongsRequestCount(desired: number): number {
+  const { activeServerId, musicLibraryFilterByServer } = useAuthStore.getState();
+  const f = activeServerId ? musicLibraryFilterByServer[activeServerId] : undefined;
+  if (f === undefined || f === 'all') return desired;
+  return Math.min(300, Math.max(desired, desired * 4));
+}
+
 export async function getRandomSongs(size = 50, genre?: string, timeout = 15000): Promise<SubsonicSong[]> {
   const params: Record<string, string | number> = { size, _t: Date.now(), ...libraryFilterParams() };
   if (genre) params.genre = genre;
@@ -252,6 +500,251 @@ export async function getAlbum(id: string): Promise<{ album: SubsonicAlbum; song
   return { album, songs: song ?? [] };
 }
 
+const MIX_RATING_PREFETCH_CONCURRENCY = 8;
+const RATING_CACHE_TTL = 7 * 60 * 1000; // 7 minutes
+const ratingCache = new Map<string, { value: number | undefined; expiresAt: number }>();
+
+function getCachedRating(key: string): number | undefined | null {
+  const entry = ratingCache.get(key);
+  if (!entry) return null; // cache miss
+  if (Date.now() > entry.expiresAt) { ratingCache.delete(key); return null; }
+  return entry.value;
+}
+
+function setCachedRating(key: string, value: number | undefined): void {
+  ratingCache.set(key, { value, expiresAt: Date.now() + RATING_CACHE_TTL });
+}
+
+function parseEntityUserRating(v: unknown): number | undefined {
+  if (v === null || v === undefined) return undefined;
+  const n = typeof v === 'number' ? v : Number(v);
+  if (!Number.isFinite(n)) return undefined;
+  return n;
+}
+
+/** Parallel `getArtist` calls to fill mix/album filters when list endpoints omit ratings. */
+export async function prefetchArtistUserRatings(
+  ids: string[],
+  concurrency = MIX_RATING_PREFETCH_CONCURRENCY,
+): Promise<Map<string, number>> {
+  const unique = [...new Set(ids.filter(Boolean))];
+  const out = new Map<string, number>();
+  if (!unique.length) return out;
+  const uncached: string[] = [];
+  for (const id of unique) {
+    const cached = getCachedRating(`artist:${id}`);
+    if (cached !== null) { if (cached !== undefined) out.set(id, cached); }
+    else uncached.push(id);
+  }
+  if (!uncached.length) return out;
+  let next = 0;
+  async function worker() {
+    for (;;) {
+      const i = next++;
+      if (i >= uncached.length) return;
+      const id = uncached[i];
+      try {
+        const { artist } = await getArtist(id);
+        const r = parseEntityUserRating(artist.userRating);
+        setCachedRating(`artist:${id}`, r);
+        if (r !== undefined) out.set(id, r);
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+  const nWorkers = Math.min(concurrency, uncached.length);
+  await Promise.all(Array.from({ length: nWorkers }, () => worker()));
+  return out;
+}
+
+/** Parallel `getAlbum` calls when `albumList2` entries lack `userRating`. */
+export async function prefetchAlbumUserRatings(
+  ids: string[],
+  concurrency = MIX_RATING_PREFETCH_CONCURRENCY,
+): Promise<Map<string, number>> {
+  const unique = [...new Set(ids.filter(Boolean))];
+  const out = new Map<string, number>();
+  if (!unique.length) return out;
+  const uncached: string[] = [];
+  for (const id of unique) {
+    const cached = getCachedRating(`album:${id}`);
+    if (cached !== null) { if (cached !== undefined) out.set(id, cached); }
+    else uncached.push(id);
+  }
+  if (!uncached.length) return out;
+  let next = 0;
+  async function worker() {
+    for (;;) {
+      const i = next++;
+      if (i >= uncached.length) return;
+      const id = uncached[i];
+      try {
+        const { album } = await getAlbum(id);
+        const r = parseEntityUserRating(album.userRating);
+        setCachedRating(`album:${id}`, r);
+        if (r !== undefined) out.set(id, r);
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+  const nWorkers = Math.min(concurrency, uncached.length);
+  await Promise.all(Array.from({ length: nWorkers }, () => worker()));
+  return out;
+}
+
+/** Paginated album stats for Statistics (playtime, counts, genre breakdown). Same TTL as rating prefetch. */
+export interface StatisticsLibraryAggregates {
+  playtimeSec: number;
+  albumsCounted: number;
+  songsCounted: number;
+  capped: boolean;
+  genres: SubsonicGenre[];
+}
+
+/** Key `prefix:serverId:folder` — Statistics caches share scope with `libraryFilterParams()`. */
+function statisticsPageCacheKey(prefix: string): string | null {
+  const { activeServerId, musicLibraryFilterByServer } = useAuthStore.getState();
+  if (!activeServerId) return null;
+  const folder = musicLibraryFilterByServer[activeServerId] ?? 'all';
+  const folderPart = folder === 'all' ? 'all' : folder;
+  return `${prefix}:${activeServerId}:${folderPart}`;
+}
+
+const statisticsAggregatesCache = new Map<string, { value: StatisticsLibraryAggregates; expiresAt: number }>();
+
+/**
+ * Walks up to 5000 newest albums (scoped by library filter). Cached per server + music folder for
+ * 7 minutes (same `RATING_CACHE_TTL` as album/artist rating prefetch).
+ * Unknown/missing album genre is stored as `value: ''`; UI should map to i18n.
+ */
+export async function fetchStatisticsLibraryAggregates(): Promise<StatisticsLibraryAggregates> {
+  const key = statisticsPageCacheKey('statsAgg');
+  if (key) {
+    const hit = statisticsAggregatesCache.get(key);
+    if (hit && Date.now() < hit.expiresAt) return hit.value;
+  }
+
+  let playtimeSec = 0;
+  let albumsCounted = 0;
+  let songsCounted = 0;
+  const genreAgg = new Map<string, { songCount: number; albumCount: number }>();
+  const pageSize = 500;
+  const maxPages = 10;
+  let capped = false;
+  let offset = 0;
+  let nextPage = getAlbumList('newest', pageSize, 0);
+  for (let page = 0; page < maxPages; page++) {
+    try {
+      const albums = await nextPage;
+      for (const a of albums) {
+        playtimeSec += a.duration ?? 0;
+        albumsCounted += 1;
+        const sc = a.songCount ?? 0;
+        songsCounted += sc;
+        const label = (a.genre?.trim()) ? a.genre.trim() : '';
+        let g = genreAgg.get(label);
+        if (!g) {
+          g = { songCount: 0, albumCount: 0 };
+          genreAgg.set(label, g);
+        }
+        g.songCount += sc;
+        g.albumCount += 1;
+      }
+      if (albums.length < pageSize) break;
+      if (page === maxPages - 1) {
+        capped = true;
+        break;
+      }
+      offset += pageSize;
+      nextPage = getAlbumList('newest', pageSize, offset);
+    } catch {
+      break;
+    }
+  }
+
+  const genres: SubsonicGenre[] = [...genreAgg.entries()]
+    .map(([value, c]) => ({ value, songCount: c.songCount, albumCount: c.albumCount }))
+    .sort((a, b) => b.songCount - a.songCount);
+
+  const result: StatisticsLibraryAggregates = {
+    playtimeSec,
+    albumsCounted,
+    songsCounted,
+    capped,
+    genres,
+  };
+  if (key) {
+    statisticsAggregatesCache.set(key, { value: result, expiresAt: Date.now() + RATING_CACHE_TTL });
+  }
+  return result;
+}
+
+/** Recent / frequent / highest album strips + artist count for Statistics. */
+export interface StatisticsOverviewData {
+  recent: SubsonicAlbum[];
+  frequent: SubsonicAlbum[];
+  highest: SubsonicAlbum[];
+  artistCount: number;
+}
+
+const statisticsOverviewCache = new Map<string, { value: StatisticsOverviewData; expiresAt: number }>();
+
+export async function fetchStatisticsOverview(): Promise<StatisticsOverviewData> {
+  const key = statisticsPageCacheKey('statsOverview');
+  if (key) {
+    const hit = statisticsOverviewCache.get(key);
+    if (hit && Date.now() < hit.expiresAt) return hit.value;
+  }
+  const [recent, frequent, highest, artists] = await Promise.all([
+    getAlbumList('recent', 20).catch(() => [] as SubsonicAlbum[]),
+    getAlbumList('frequent', 12).catch(() => [] as SubsonicAlbum[]),
+    getAlbumList('highest', 12).catch(() => [] as SubsonicAlbum[]),
+    getArtists().catch(() => [] as SubsonicArtist[]),
+  ]);
+  const result: StatisticsOverviewData = {
+    recent,
+    frequent,
+    highest,
+    artistCount: artists.length,
+  };
+  if (key) {
+    statisticsOverviewCache.set(key, { value: result, expiresAt: Date.now() + RATING_CACHE_TTL });
+  }
+  return result;
+}
+
+/** Format (suffix) histogram from a random sample for Statistics. */
+export interface StatisticsFormatSample {
+  rows: { format: string; count: number }[];
+  sampleSize: number;
+}
+
+const statisticsFormatCache = new Map<string, { value: StatisticsFormatSample; expiresAt: number }>();
+
+export async function fetchStatisticsFormatSample(): Promise<StatisticsFormatSample> {
+  const key = statisticsPageCacheKey('statsFormat');
+  if (key) {
+    const hit = statisticsFormatCache.get(key);
+    if (hit && Date.now() < hit.expiresAt) return hit.value;
+  }
+  const songs = await getRandomSongs(500).catch(() => [] as SubsonicSong[]);
+  const counts: Record<string, number> = {};
+  for (const song of songs) {
+    const fmt = song.suffix?.toUpperCase() ?? 'Unknown';
+    counts[fmt] = (counts[fmt] ?? 0) + 1;
+  }
+  const rows = Object.entries(counts)
+    .map(([format, count]) => ({ format, count }))
+    .sort((a, b) => b.count - a.count);
+  const result: StatisticsFormatSample = { rows, sampleSize: songs.length };
+  if (key) {
+    statisticsFormatCache.set(key, { value: result, expiresAt: Date.now() + RATING_CACHE_TTL });
+  }
+  return result;
+}
+
 export async function getArtists(): Promise<SubsonicArtist[]> {
   const data = await api<{ artists: { index: Array<{ artist: SubsonicArtist[] }> } }>('getArtists.view', {
     ...libraryFilterParams(),
@@ -266,15 +759,21 @@ export async function getArtist(id: string): Promise<{ artist: SubsonicArtist; a
   return { artist, albums: album ?? [] };
 }
 
-export async function getArtistInfo(id: string): Promise<SubsonicArtistInfo> {
-  const data = await api<{ artistInfo2: SubsonicArtistInfo }>('getArtistInfo2.view', { id, count: 5 });
+export async function getArtistInfo(id: string, options?: { similarArtistCount?: number }): Promise<SubsonicArtistInfo> {
+  const count = options?.similarArtistCount ?? 5;
+  const data = await api<{ artistInfo2: SubsonicArtistInfo }>('getArtistInfo2.view', { id, count, ...libraryFilterParams() });
   return data.artistInfo2 ?? {};
 }
 
 export async function getTopSongs(artist: string): Promise<SubsonicSong[]> {
   try {
-    const data = await api<{ topSongs: { song: SubsonicSong[] } }>('getTopSongs.view', { artist, count: 5 });
-    return data.topSongs?.song ?? [];
+    const { activeServerId, musicLibraryFilterByServer } = useAuthStore.getState();
+    const scoped = activeServerId && musicLibraryFilterByServer[activeServerId] && musicLibraryFilterByServer[activeServerId] !== 'all';
+    const topCount = scoped ? 20 : 5;
+    const data = await api<{ topSongs: { song: SubsonicSong[] } }>('getTopSongs.view', { artist, count: topCount, ...libraryFilterParams() });
+    const raw = data.topSongs?.song ?? [];
+    const filtered = await filterSongsToActiveLibrary(raw);
+    return filtered.slice(0, 5);
   } catch {
     return [];
   }
@@ -282,8 +781,26 @@ export async function getTopSongs(artist: string): Promise<SubsonicSong[]> {
 
 export async function getSimilarSongs2(id: string, count = 50): Promise<SubsonicSong[]> {
   try {
-    const data = await api<{ similarSongs2: { song: SubsonicSong[] } }>('getSimilarSongs2.view', { id, count });
-    return data.similarSongs2?.song ?? [];
+    const requestCount = similarSongsRequestCount(count);
+    const data = await api<{ similarSongs2: { song: SubsonicSong[] } }>('getSimilarSongs2.view', { id, count: requestCount, ...libraryFilterParams() });
+    const raw = data.similarSongs2?.song ?? [];
+    const filtered = await filterSongsToActiveLibrary(raw);
+    return filtered.slice(0, count);
+  } catch {
+    return [];
+  }
+}
+
+/** Similar tracks for a song id (Subsonic `getSimilarSongs`) — Navidrome + AudioMuse Instant Mix. */
+export async function getSimilarSongs(id: string, count = 50): Promise<SubsonicSong[]> {
+  try {
+    const requestCount = similarSongsRequestCount(count);
+    const data = await api<{ similarSongs: { song: SubsonicSong | SubsonicSong[] } }>('getSimilarSongs.view', { id, count: requestCount, ...libraryFilterParams() });
+    const raw = data.similarSongs?.song;
+    if (!raw) return [];
+    const list = Array.isArray(raw) ? raw : [raw];
+    const filtered = await filterSongsToActiveLibrary(list);
+    return filtered.slice(0, count);
   } catch {
     return [];
   }
@@ -373,6 +890,28 @@ export async function setRating(id: string, rating: number): Promise<void> {
   await api('setRating.view', { id, rating });
 }
 
+/** How aggressively we assume `setRating` accepts album/artist ids (OpenSubsonic-style). */
+export type EntityRatingSupportLevel = 'track_only' | 'full';
+
+/**
+ * Probe server for OpenSubsonic extensions. When `openSubsonic: true`, we treat album/artist
+ * rating as supported (same `setRating.view` + entity id); otherwise track-only.
+ */
+export async function probeEntityRatingSupport(): Promise<EntityRatingSupportLevel> {
+  try {
+    const data = await api<{ openSubsonic?: boolean; openSubsonicExtensions?: unknown[] }>(
+      'getOpenSubsonicExtensions.view',
+      {},
+      8000,
+    );
+    if (data.openSubsonic === true) return 'full';
+    if (Array.isArray(data.openSubsonicExtensions)) return 'full';
+    return 'track_only';
+  } catch {
+    return 'track_only';
+  }
+}
+
 export async function scrobbleSong(id: string, time: number): Promise<void> {
   try {
     await api('scrobble.view', { id, time, submission: true });
@@ -661,7 +1200,10 @@ export interface SubsonicLyricLine {
 }
 
 export interface SubsonicStructuredLyrics {
-  issynced: boolean;
+  /** OpenSubsonic spec field name (Navidrome ≥ 0.50.0 / any OpenSubsonic server). */
+  synced?: boolean;
+  /** Legacy / alternate casing used by some older Subsonic-compatible servers. */
+  issynced?: boolean;
   lang?: string;
   offset?: number;
   displayArtist?: string;
@@ -683,7 +1225,7 @@ export async function getLyricsBySongId(id: string): Promise<SubsonicStructuredL
     );
     const list = data.lyricsList?.structuredLyrics;
     if (!list || list.length === 0) return null;
-    return list.find(l => l.issynced) ?? list[0];
+    return list.find(l => l.synced || l.issynced) ?? list[0];
   } catch {
     // Server doesn't support the endpoint or track has no embedded lyrics
     return null;

src/components/AlbumCard.tsx

@@ -1,6 +1,6 @@
 import React, { memo } from 'react';
 import { useNavigate } from 'react-router-dom';
-import { Play, HardDriveDownload } from 'lucide-react';
+import { Play, HardDriveDownload, Check } from 'lucide-react';
 import { SubsonicAlbum, buildCoverArtUrl, coverArtCacheKey } from '../api/subsonic';
 import { usePlayerStore } from '../store/playerStore';
 import { useOfflineStore } from '../store/offlineStore';
@@ -11,9 +11,13 @@ import { useDragDrop } from '../contexts/DragDropContext';
 
 interface AlbumCardProps {
   album: SubsonicAlbum;
+  selected?: boolean;
+  selectionMode?: boolean;
+  onToggleSelect?: (id: string) => void;
+  showRating?: boolean;
 }
 
-function AlbumCard({ album }: AlbumCardProps) {
+function AlbumCard({ album, selected, selectionMode, onToggleSelect, showRating = false }: AlbumCardProps) {
   const navigate = useNavigate();
   const openContextMenu = usePlayerStore(s => s.openContextMenu);
   const serverId = useAuthStore(s => s.activeServerId ?? '');
@@ -25,20 +29,26 @@ function AlbumCard({ album }: AlbumCardProps) {
   const coverUrl = album.coverArt ? buildCoverArtUrl(album.coverArt, 300) : '';
   const psyDrag = useDragDrop();
 
+  const handleClick = () => {
+    if (selectionMode) { onToggleSelect?.(album.id); return; }
+    navigate(`/album/${album.id}`);
+  };
+
   return (
     <div
-      className="album-card card"
-      onClick={() => navigate(`/album/${album.id}`)}
+      className={`album-card card${selectionMode ? ' album-card--selectable' : ''}${selected ? ' album-card--selected' : ''}`}
+      onClick={handleClick}
       role="button"
       tabIndex={0}
       aria-label={`${album.name} von ${album.artist}`}
-      onKeyDown={e => e.key === 'Enter' && navigate(`/album/${album.id}`)}
+      onKeyDown={e => e.key === 'Enter' && handleClick()}
       onContextMenu={(e) => {
+        if (selectionMode) { e.preventDefault(); return; }
         e.preventDefault();
         openContextMenu(e.clientX, e.clientY, album, 'album');
       }}
       onMouseDown={e => {
-        if (e.button !== 0) return;
+        if (selectionMode || e.button !== 0) return;
         e.preventDefault();
         const sx = e.clientX, sy = e.clientY;
         const onMove = (me: MouseEvent) => {
@@ -64,20 +74,27 @@ function AlbumCard({ album }: AlbumCardProps) {
             </svg>
           </div>
         )}
-        {isOffline && (
+        {isOffline && !selectionMode && (
           <div className="album-card-offline-badge" aria-label="Offline available">
             <HardDriveDownload size={12} />
           </div>
         )}
-        <div className="album-card-play-overlay">
-          <button
-            className="album-card-details-btn"
-            onClick={e => { e.stopPropagation(); playAlbum(album.id); }}
-            aria-label={`${album.name} abspielen`}
-          >
-            <Play size={15} fill="currentColor" />
-          </button>
-        </div>
+        {selectionMode && (
+          <div className={`album-card-select-check${selected ? ' album-card-select-check--on' : ''}`}>
+            {selected && <Check size={14} strokeWidth={3} />}
+          </div>
+        )}
+        {!selectionMode && (
+          <div className="album-card-play-overlay">
+            <button
+              className="album-card-details-btn"
+              onClick={e => { e.stopPropagation(); playAlbum(album.id); }}
+              aria-label={`${album.name} abspielen`}
+            >
+              <Play size={15} fill="currentColor" />
+            </button>
+          </div>
+        )}
       </div>
       <div className="album-card-info">
         <p className="album-card-title truncate">{album.name}</p>
@@ -87,6 +104,13 @@ function AlbumCard({ album }: AlbumCardProps) {
           onClick={e => { if (album.artistId) { e.stopPropagation(); navigate(`/artist/${album.artistId}`); } }}
         >{album.artist}</p>
         {album.year && <p className="album-card-year">{album.year}</p>}
+        {showRating && (album.userRating ?? 0) > 0 && (
+          <div className="album-card-rating-row">
+            <span className="album-card-rating-stars">
+              {'★'.repeat(album.userRating!)}{'☆'.repeat(5 - album.userRating!)}
+            </span>
+          </div>
+        )}
       </div>
     </div>
   );

src/components/AlbumHeader.tsx

@@ -1,11 +1,13 @@
 import React, { useState } from 'react';
 import { useNavigate } from 'react-router-dom';
-import { Play, Heart, ExternalLink, X, ChevronLeft, Download, ListPlus, HardDriveDownload, Loader2 } from 'lucide-react';
+import { Play, Heart, ExternalLink, X, ChevronLeft, Download, ListPlus, HardDriveDownload, Loader2, Highlighter } from 'lucide-react';
 import { SubsonicSong, buildCoverArtUrl } from '../api/subsonic';
 import CachedImage from './CachedImage';
 import CoverLightbox from './CoverLightbox';
 import { useTranslation } from 'react-i18next';
 import { useIsMobile } from '../hooks/useIsMobile';
+import StarRating from './StarRating';
+import type { EntityRatingSupportLevel } from '../api/subsonic';
 
 function formatDuration(seconds: number): string {
   const h = Math.floor(seconds / 3600);
@@ -85,6 +87,10 @@ interface AlbumHeaderProps {
   onEnqueueAll: () => void;
   onBio: () => void;
   onCloseBio: () => void;
+  entityRatingValue: number;
+  onEntityRatingChange: (rating: number) => void;
+  /** `unknown` = probe pending or not run; from `entityRatingSupportByServer`. */
+  entityRatingSupport: EntityRatingSupportLevel | 'unknown';
 }
 
 export default function AlbumHeader({
@@ -107,6 +113,9 @@ export default function AlbumHeader({
   onEnqueueAll,
   onBio,
   onCloseBio,
+  entityRatingValue,
+  onEntityRatingChange,
+  entityRatingSupport,
 }: AlbumHeaderProps) {
   const { t } = useTranslation();
   const navigate = useNavigate();
@@ -186,6 +195,15 @@ export default function AlbumHeader({
                   </>
                 )}
               </div>
+              <div className="album-detail-entity-rating">
+                <span className="album-detail-entity-rating-label">{t('entityRating.albumShort')}</span>
+                <StarRating
+                  value={entityRatingValue}
+                  onChange={onEntityRatingChange}
+                  disabled={entityRatingSupport === 'track_only'}
+                  labelKey="entityRating.albumAriaLabel"
+                />
+              </div>
               {isMobile ? (
                 <div className="album-detail-actions-mobile">
                   {/* Row 1 — Primary actions */}
@@ -225,7 +243,7 @@ export default function AlbumHeader({
                       aria-label={t('albumDetail.artistBio')}
                       data-tooltip={t('albumDetail.artistBio')}
                     >
-                      <ExternalLink size={16} />
+                      <Highlighter size={16} />
                     </button>
 
                     {downloadProgress !== null ? (
@@ -295,7 +313,7 @@ export default function AlbumHeader({
                   </button>
 
                   <button className="btn btn-ghost" id="album-bio-btn" onClick={onBio}>
-                    <ExternalLink size={16} /> {t('albumDetail.artistBio')}
+                    <Highlighter size={16} /> {t('albumDetail.artistBio')}
                   </button>
 
                   {downloadProgress !== null ? (

src/components/AlbumRow.tsx

@@ -12,9 +12,10 @@ interface Props {
   moreLink?: string;
   moreText?: string;
   onLoadMore?: () => Promise<void>;
+  showRating?: boolean;
 }
 
-export default function AlbumRow({ title, titleLink, albums, moreLink, moreText, onLoadMore }: Props) {
+export default function AlbumRow({ title, titleLink, albums, moreLink, moreText, onLoadMore, showRating }: Props) {
   const { t } = useTranslation();
   const scrollRef = useRef<HTMLDivElement>(null);
   const navigate = useNavigate();
@@ -89,7 +90,7 @@ export default function AlbumRow({ title, titleLink, albums, moreLink, moreText,
       
       <div className="album-grid-wrapper">
         <div className="album-grid" ref={scrollRef} onScroll={handleScroll}>
-          {albums.map(a => <AlbumCard key={a.id} album={a} />)}
+          {albums.map(a => <AlbumCard key={a.id} album={a} showRating={showRating} />)}
           {loadingMore && (
             <div className="album-card-more" style={{ cursor: 'default' }}>
               <div style={{ padding: '1rem', background: 'var(--bg-app)', borderRadius: '50%' }}>

src/components/AlbumTrackList.tsx

@@ -8,6 +8,7 @@ import { useNavigate } from 'react-router-dom';
 import { useDragDrop } from '../contexts/DragDropContext';
 import { AddToPlaylistSubmenu } from './ContextMenu';
 import { useIsMobile } from '../hooks/useIsMobile';
+import StarRating from './StarRating';
 
 function formatDuration(seconds: number): string {
   const h = Math.floor(seconds / 3600);
@@ -24,29 +25,6 @@ function codecLabel(song: { suffix?: string; bitRate?: number }): string {
   return parts.join(' ');
 }
 
-function StarRating({ value, onChange }: { value: number; onChange: (r: number) => void }) {
-  const { t } = useTranslation();
-  const [hover, setHover] = React.useState(0);
-  return (
-    <div className="star-rating" role="radiogroup" aria-label={t('albumDetail.ratingLabel')}>
-      {[1, 2, 3, 4, 5].map(n => (
-        <button
-          key={n}
-          className={`star ${(hover || value) >= n ? 'filled' : ''}`}
-          onMouseEnter={() => setHover(n)}
-          onMouseLeave={() => setHover(0)}
-          onClick={() => onChange(n)}
-          aria-label={`${n}`}
-          role="radio"
-          aria-checked={(hover || value) >= n}
-        >
-          ★
-        </button>
-      ))}
-    </div>
-  );
-}
-
 // ── Column configuration ──────────────────────────────────────────────────────
 // 'num'   → always 60 px fixed, no resize handle
 // 'title' → minmax(150px, 1fr) via flex:true, absorbs window-resize changes
@@ -58,14 +36,14 @@ const COLUMNS: readonly ColDef[] = [
   { key: 'artist',   i18nKey: 'trackArtist',   minWidth: 80,  defaultWidth: 180, required: false },
   { key: 'favorite', i18nKey: 'trackFavorite', minWidth: 50,  defaultWidth: 70,  required: false },
   { key: 'rating',   i18nKey: 'trackRating',   minWidth: 80,  defaultWidth: 120, required: false },
-  { key: 'duration', i18nKey: 'trackDuration', minWidth: 50,  defaultWidth: 65,  required: false },
+  { key: 'duration', i18nKey: 'trackDuration', minWidth: 72,  defaultWidth: 92,  required: false },
   { key: 'format',   i18nKey: 'trackFormat',   minWidth: 60,  defaultWidth: 90,  required: false },
   { key: 'genre',    i18nKey: 'trackGenre',    minWidth: 60,  defaultWidth: 90,  required: false },
 ];
 
 type ColKey = 'num' | 'title' | 'artist' | 'favorite' | 'rating' | 'duration' | 'format' | 'genre';
 
-// Columns where cell content should be centred (both header and rows)
+// Columns where header label is centred in the cell (matches row controls below)
 const CENTERED_COLS = new Set<ColKey>(['favorite', 'rating', 'duration']);
 
 // ── Props ─────────────────────────────────────────────────────────────────────
@@ -76,6 +54,8 @@ interface AlbumTrackListProps {
   currentTrack: Track | null;
   isPlaying: boolean;
   ratings: Record<string, number>;
+  /** Merged after local `ratings` (e.g. skip→1★ optimistic updates). */
+  userRatingOverrides: Record<string, number>;
   starredSongs: Set<string>;
   onPlaySong: (song: SubsonicSong) => void;
   onRate: (songId: string, rating: number) => void;
@@ -89,6 +69,7 @@ export default function AlbumTrackList({
   currentTrack,
   isPlaying,
   ratings,
+  userRatingOverrides,
   starredSongs,
   onPlaySong,
   onRate,
@@ -193,13 +174,21 @@ export default function AlbumTrackList({
       );
     }
 
-    // px-width columns: centred or left-aligned label + right-edge divider (except last col)
-    // direction=1: drag right → this column grows, title (1fr) shrinks
+    // px-width columns: centred (compact controls) or left-aligned label + right-edge divider
     const isResizable = !isLastCol;
     return (
-      <div key={key} data-align={isCentered ? 'center' : 'start'} style={{ position: 'relative', padding: 0, margin: 0, minWidth: 0, overflow: 'hidden' }}>
-        <div style={{ display: 'flex', width: '100%', height: '100%', alignItems: 'center', justifyContent: isCentered ? 'center' : 'flex-start', paddingLeft: isCentered ? 0 : 12 }}>
-          <span style={{ overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{label}</span>
+      <div key={key} style={{ position: 'relative', padding: 0, margin: 0, minWidth: 0, overflow: 'hidden' }}>
+        <div
+          style={{
+            display: 'flex',
+            width: '100%',
+            height: '100%',
+            alignItems: 'center',
+            justifyContent: isCentered ? 'center' : 'flex-start',
+            paddingLeft: isCentered ? 0 : 12,
+          }}
+        >
+          <span style={{ whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis' }}>{label}</span>
         </div>
         {isResizable && (
           <div className="col-resize-handle" onMouseDown={e => startResize(e, colIndex, 1)} />
@@ -238,18 +227,27 @@ export default function AlbumTrackList({
             <span className="track-title">{song.title}</span>
           </div>
         );
-      case 'artist':
+      case 'artist': {
+        const artistRefs = song.artists && song.artists.length > 0
+          ? song.artists
+          : [{ id: song.artistId, name: song.artist }];
         return (
           <div key="artist" className="track-artist-cell">
-            <span
-              className={`track-artist${song.artistId ? ' track-artist-link' : ''}`}
-              style={{ cursor: song.artistId ? 'pointer' : 'default' }}
-              onClick={e => { if (song.artistId) { e.stopPropagation(); navigate(`/artist/${song.artistId}`); } }}
-            >
-              {song.artist}
-            </span>
+            {artistRefs.map((a, i) => (
+              <React.Fragment key={a.id ?? a.name ?? i}>
+                {i > 0 && <span className="track-artist-sep">&nbsp;·&nbsp;</span>}
+                <span
+                  className={`track-artist${a.id ? ' track-artist-link' : ''}`}
+                  style={{ cursor: a.id ? 'pointer' : 'default' }}
+                  onClick={e => { if (a.id) { e.stopPropagation(); navigate(`/artist/${a.id}`); } }}
+                >
+                  {a.name ?? song.artist}
+                </span>
+              </React.Fragment>
+            ))}
           </div>
         );
+      }
       case 'favorite':
         return (
           <div key="favorite" className="track-star-cell">
@@ -266,7 +264,7 @@ export default function AlbumTrackList({
         return (
           <StarRating
             key="rating"
-            value={ratings[song.id] ?? song.userRating ?? 0}
+            value={ratings[song.id] ?? userRatingOverrides[song.id] ?? song.userRating ?? 0}
             onChange={r => onRate(song.id, r)}
           />
         );

src/components/AppUpdater.tsx

@@ -1,9 +1,15 @@
-import React, { useEffect, useState } from 'react';
+import React, { useEffect, useState, useRef } from 'react';
 import { createPortal } from 'react-dom';
 import { open } from '@tauri-apps/plugin-shell';
-import { RefreshCw, X } from 'lucide-react';
+import { listen } from '@tauri-apps/api/event';
+import { dirname } from '@tauri-apps/api/path';
+import { invoke } from '@tauri-apps/api/core';
+import { ArrowUpCircle, ChevronDown, Download, FolderOpen, X } from 'lucide-react';
 import { useTranslation } from 'react-i18next';
 import { version as currentVersion } from '../../package.json';
+import { IS_LINUX, IS_MACOS, IS_WINDOWS } from '../utils/platform';
+
+const SKIP_KEY = 'psysonic_skipped_update_version';
 
 // Semver comparison: returns true if `a` is newer than `b`
 function isNewer(a: string, b: string): boolean {
@@ -16,57 +22,327 @@ function isNewer(a: string, b: string): boolean {
   return false;
 }
 
+function fmtBytes(n: number): string {
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(0)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+// Minimal inline-markdown renderer (bold, italic, code)
+// IMPORTANT: regex must have NO nested capture groups — split() includes captured
+// groups in the result, and nested groups produce undefined entries that crash on .startsWith()
+function renderInline(text: string): React.ReactNode[] {
+  const parts = text.split(/(\*\*[^*]+\*\*|\*[^*]+\*|`[^`]+`)/g);
+  return parts.map((part, i) => {
+    if (!part) return null;
+    if (part.startsWith('**') && part.endsWith('**'))
+      return <strong key={i}>{part.slice(2, -2)}</strong>;
+    if (part.startsWith('*') && part.endsWith('*'))
+      return <em key={i}>{part.slice(1, -1)}</em>;
+    if (part.startsWith('`') && part.endsWith('`'))
+      return <code key={i} className="changelog-code">{part.slice(1, -1)}</code>;
+    return part;
+  });
+}
+
+function renderChangelog(body: string) {
+  return body.split('\n').map((line, i) => {
+    if (line.startsWith('### '))
+      return <div key={i} className="changelog-h3">{renderInline(line.slice(4))}</div>;
+    if (line.startsWith('#### '))
+      return <div key={i} className="changelog-h4">{renderInline(line.slice(5))}</div>;
+    if (line.startsWith('## '))
+      return null; // skip nested release headers in body
+    if (line.startsWith('- '))
+      return <div key={i} className="changelog-item">{renderInline(line.slice(2))}</div>;
+    if (line.trim() === '') return null;
+    return <div key={i} className="changelog-text">{renderInline(line)}</div>;
+  });
+}
+
+interface GithubAsset {
+  name: string;
+  browser_download_url: string;
+  size: number;
+}
+
+interface ReleaseData {
+  version: string;
+  tag: string;
+  body: string;
+  assets: GithubAsset[];
+}
+
+function pickAsset(assets: GithubAsset[]): GithubAsset | undefined {
+  if (IS_WINDOWS) {
+    return assets.find(a => a.name.endsWith('-setup.exe'))
+      ?? assets.find(a => a.name.endsWith('.exe'));
+  }
+  if (IS_MACOS) {
+    // Prefer Apple Silicon, fall back to Intel
+    return assets.find(a => a.name.endsWith('.dmg') && a.name.includes('aarch64'))
+      ?? assets.find(a => a.name.endsWith('.dmg'));
+  }
+  if (IS_LINUX) {
+    // AppImage > deb > rpm
+    return assets.find(a => a.name.endsWith('.AppImage'))
+      ?? assets.find(a => a.name.endsWith('.deb'))
+      ?? assets.find(a => a.name.endsWith('.rpm'));
+  }
+  return undefined;
+}
+
+type DlState = 'idle' | 'downloading' | 'done' | 'error';
+
 export default function AppUpdater() {
   const { t } = useTranslation();
-  const [newVersion, setNewVersion] = useState<string | null>(null);
+  const [release, setRelease] = useState<ReleaseData | null>(null);
   const [dismissed, setDismissed] = useState(false);
+  const [changelogOpen, setChangelogOpen] = useState(false);
+  const [isArch, setIsArch] = useState(false);
+  const [dlState, setDlState] = useState<DlState>('idle');
+  const [dlProgress, setDlProgress] = useState({ bytes: 0, total: 0 });
+  const [dlPath, setDlPath] = useState('');
+  const [dlError, setDlError] = useState('');
+  const unlistenRef = useRef<(() => void) | null>(null);
+
+  const fetchRelease = async (preview = false) => {
+    try {
+      const res = await fetch('https://api.github.com/repos/Psychotoxical/psysonic/releases/latest');
+      if (!res.ok) return;
+      const data = await res.json();
+      const tag: string = data.tag_name ?? '';
+      const version = tag.replace(/^[^0-9]*/, '');
+      if (!version) return;
+      if (!preview) {
+        if (!isNewer(version, currentVersion)) return;
+        const skipped = localStorage.getItem(SKIP_KEY);
+        if (skipped === version) return;
+      }
+      setDismissed(false);
+      setDlState('idle');
+      setRelease({
+        version,
+        tag,
+        body: (data.body ?? '').trim(),
+        assets: data.assets ?? [],
+      });
+      if (IS_LINUX) {
+        const arch = await invoke<boolean>('check_arch_linux');
+        setIsArch(arch);
+      }
+    } catch {
+      // No network or rate-limited — stay idle
+    }
+  };
 
   useEffect(() => {
     let cancelled = false;
-    const timer = setTimeout(async () => {
-      if (cancelled) return;
-      try {
-        const res = await fetch('https://api.github.com/repos/Psychotoxical/psysonic/releases/latest');
-        if (!res.ok || cancelled) return;
-        const data = await res.json();
-        const tag: string = data.tag_name ?? '';
-        if (!cancelled && tag && isNewer(tag, currentVersion)) {
-          setNewVersion(tag.replace(/^[^0-9]*/, ''));
-        }
-      } catch {
-        // No network or rate-limited — stay idle
-      }
-    }, 4000);
-    return () => { cancelled = true; clearTimeout(timer); };
+    const timer = setTimeout(() => { if (!cancelled) fetchRelease(); }, 4000);
+
+    const handler = () => fetchRelease(true);
+    window.addEventListener('psysonic:preview-update', handler);
+
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+      window.removeEventListener('psysonic:preview-update', handler);
+    };
+  // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
-  if (!newVersion || dismissed) return null;
+  // Clean up download listener when component unmounts
+  useEffect(() => {
+    return () => { unlistenRef.current?.(); };
+  }, []);
+
+  if (!release || dismissed) return null;
+
+  const asset = pickAsset(release.assets);
+  const showAurHint = IS_LINUX && isArch;
+
+  const handleSkip = () => {
+    localStorage.setItem(SKIP_KEY, release.version);
+    setDismissed(true);
+  };
+
+  const handleDownload = async () => {
+    if (!asset) return;
+    setDlState('downloading');
+    setDlProgress({ bytes: 0, total: asset.size });
+    setDlError('');
+
+    const unlisten = await listen<{ bytes: number; total: number | null }>(
+      'update:download:progress',
+      e => {
+        setDlProgress({
+          bytes: e.payload.bytes,
+          total: e.payload.total ?? asset.size,
+        });
+      }
+    );
+    unlistenRef.current = unlisten;
+
+    try {
+      const finalPath = await invoke<string>('download_update', {
+        url: asset.browser_download_url,
+        filename: asset.name,
+      });
+      unlisten();
+      unlistenRef.current = null;
+      setDlPath(finalPath);
+      setDlState('done');
+    } catch (e) {
+      unlisten();
+      unlistenRef.current = null;
+      setDlError(String(e));
+      setDlState('error');
+    }
+  };
+
+  const handleShowFolder = async () => {
+    // tauri-plugin-shell's open() only allows https:// per capability scope —
+    // local paths are blocked and fail silently. Delegate to Rust instead.
+    const dir = await dirname(dlPath);
+    await invoke('open_folder', { path: dir });
+  };
+
+  const pct = dlProgress.total > 0
+    ? Math.min(100, Math.round((dlProgress.bytes / dlProgress.total) * 100))
+    : 0;
 
   return createPortal(
-    <div className="app-updater-toast">
-      <div className="app-updater-header">
-        <RefreshCw size={13} />
-        <span className="app-updater-label">{t('common.updaterAvailable')}</span>
-        <button className="app-updater-dismiss" onClick={() => setDismissed(true)} aria-label="Dismiss">
-          <X size={12} />
-        </button>
+    <>
+      <div className="eq-popup-backdrop" onClick={() => setDismissed(true)} style={{ zIndex: 3000 }} />
+      <div
+        className="eq-popup update-modal"
+        style={{ zIndex: 3001 }}
+        onClick={e => e.stopPropagation()}
+      >
+        {/* Header */}
+        <div className="eq-popup-header update-modal-header">
+          <ArrowUpCircle size={16} style={{ color: 'var(--accent)', flexShrink: 0 }} />
+          <div style={{ flex: 1, minWidth: 0 }}>
+            <span className="eq-popup-title">{t('common.updaterModalTitle')}</span>
+            <span className="update-modal-versions">
+              v{currentVersion} → <strong>v{release.version}</strong>
+            </span>
+          </div>
+          <button
+            className="app-updater-dismiss"
+            onClick={() => setDismissed(true)}
+            data-tooltip={t('common.updaterRemindBtn')}
+            data-tooltip-pos="bottom"
+          >
+            <X size={14} />
+          </button>
+        </div>
+
+        {/* Scrollable body: changelog + download area — single overflow container */}
+        <div className="update-modal-body">
+          {/* Collapsible Changelog */}
+          {release.body && (
+            <div className="update-modal-changelog">
+              <button
+                type="button"
+                className="update-modal-changelog-toggle"
+                onClick={() => setChangelogOpen(v => !v)}
+              >
+                <ChevronDown
+                  size={13}
+                  style={{
+                    transform: changelogOpen ? 'rotate(180deg)' : 'none',
+                    transition: 'transform 0.2s',
+                    flexShrink: 0,
+                  }}
+                />
+                {t('common.updaterChangelog')}
+              </button>
+              {changelogOpen && (
+                <div className="update-modal-changelog-body">
+                  {renderChangelog(release.body)}
+                </div>
+              )}
+            </div>
+          )}
+
+        {/* Download / AUR area */}
+        <div className="update-modal-download-area">
+          {showAurHint ? (
+            <div className="update-modal-aur">
+              <div className="update-modal-aur-title">{t('common.updaterAurHint')}</div>
+              <code className="update-modal-aur-cmd">yay -S psysonic-bin</code>
+              <code className="update-modal-aur-cmd update-modal-aur-alt">sudo pacman -Syu psysonic-bin</code>
+            </div>
+          ) : asset ? (
+            <>
+              {dlState === 'idle' && (
+                <div className="update-modal-asset">
+                  <span className="update-modal-asset-name">{asset.name}</span>
+                  <span className="update-modal-asset-size">{fmtBytes(asset.size)}</span>
+                </div>
+              )}
+              {dlState === 'downloading' && (
+                <div className="update-modal-progress">
+                  <div className="app-updater-progress-bar">
+                    <div className="app-updater-progress-fill" style={{ width: `${pct}%` }} />
+                  </div>
+                  <span className="app-updater-pct">{pct}%</span>
+                  <span className="update-modal-dl-bytes">
+                    {fmtBytes(dlProgress.bytes)}
+                    {dlProgress.total > 0 && ` / ${fmtBytes(dlProgress.total)}`}
+                  </span>
+                </div>
+              )}
+              {dlState === 'done' && (
+                <div className="update-modal-done">
+                  <div className="update-modal-done-title">{t('common.updaterDone')}</div>
+                  <div className="update-modal-done-hint">{t('common.updaterInstallHint')}</div>
+                  <button className="btn btn-surface update-modal-folder-btn" onClick={handleShowFolder}>
+                    <FolderOpen size={14} />
+                    {t('common.updaterShowFolder')}
+                  </button>
+                </div>
+              )}
+              {dlState === 'error' && (
+                <div className="app-updater-error">{dlError || t('common.updaterErrorMsg')}</div>
+              )}
+            </>
+          ) : (
+            <div className="update-modal-asset-none">
+              <button
+                className="app-updater-btn-primary"
+                onClick={() => open(`https://github.com/Psychotoxical/psysonic/releases/tag/${release.tag}`)}
+              >
+                {t('common.updaterOpenGitHub')}
+              </button>
+            </div>
+          )}
+        </div>
+        </div>{/* end update-modal-body */}
+
+        {/* Footer buttons */}
+        <div className="update-modal-footer">
+          <button className="btn btn-ghost update-modal-skip" onClick={handleSkip}>
+            {t('common.updaterSkipBtn')}
+          </button>
+          <div style={{ flex: 1 }} />
+          <button className="btn btn-surface" onClick={() => setDismissed(true)}>
+            {t('common.updaterRemindBtn')}
+          </button>
+          {!showAurHint && asset && dlState === 'idle' && (
+            <button className="btn btn-primary" onClick={handleDownload}>
+              <Download size={14} />
+              {t('common.updaterDownloadBtn')}
+            </button>
+          )}
+          {dlState === 'error' && (
+            <button className="btn btn-primary" onClick={handleDownload}>
+              {t('common.updaterRetryBtn')}
+            </button>
+          )}
+        </div>
       </div>
-      <div className="app-updater-version">{t('common.updaterVersion', { version: newVersion })}</div>
-      <div className="app-updater-actions">
-        <button
-          className="app-updater-btn-primary"
-          onClick={() => open('https://github.com/Psychotoxical/psysonic/releases/latest')}
-        >
-          GitHub
-        </button>
-        <button
-          className="app-updater-btn-secondary"
-          onClick={() => open('https://psysonic.psychotoxic.eu/#downloads')}
-        >
-          {t('common.updaterWebsite')}
-        </button>
-      </div>
-    </div>,
+    </>,
     document.body
   );
 }

src/components/CachedImage.tsx

@@ -26,8 +26,9 @@ export function useCachedUrl(fetchUrl: string, cacheKey: string, fallbackToFetch
   return fallbackToFetch ? (resolved || fetchUrl) : resolved;
 }
 
-export default function CachedImage({ src, cacheKey, style, onLoad, ...props }: CachedImageProps) {
+export default function CachedImage({ src, cacheKey, style, onLoad, onError, ...props }: CachedImageProps) {
   const [inView, setInView] = useState(false);
+  const [fallbackSrc, setFallbackSrc] = useState<string | undefined>(undefined);
   const imgRef = useRef<HTMLImageElement>(null);
 
   useEffect(() => {
@@ -49,14 +50,34 @@ export default function CachedImage({ src, cacheKey, style, onLoad, ...props }:
   // URL upgrades within the same image — avoids the end-of-load flash.
   useEffect(() => {
     setLoaded(false);
+    setFallbackSrc(undefined);
   }, [cacheKey]);
 
+  const handleError = (e: React.SyntheticEvent<HTMLImageElement>) => {
+    if (onError) {
+      // Caller wants custom error handling (e.g. hide the element)
+      onError(e);
+    } else {
+      // Nullify the DOM-level handler first to prevent any infinite loop
+      e.currentTarget.onerror = null;
+      setFallbackSrc('/logo-psysonic.png');
+    }
+  };
+
+  const isFallback = fallbackSrc !== undefined;
+  const finalSrc = fallbackSrc ?? (resolvedSrc || undefined);
+
+  const fallbackStyle: React.CSSProperties = isFallback
+    ? { objectFit: 'contain', background: 'var(--bg-card, var(--ctp-surface0, #313244))', padding: '15%' }
+    : {};
+
   return (
     <img
       ref={imgRef}
-      src={resolvedSrc || undefined}
-      style={{ ...style, opacity: loaded ? 1 : 0, transition: 'opacity 0.15s ease' }}
+      src={finalSrc}
+      style={{ ...style, opacity: loaded ? 1 : 0, transition: 'opacity 0.15s ease', ...fallbackStyle }}
       onLoad={e => { setLoaded(true); onLoad?.(e); }}
+      onError={handleError}
       {...props}
     />
   );

src/components/ContextMenu.tsx

@@ -1,17 +1,21 @@
 import React, { useEffect, useLayoutEffect, useRef, useState } from 'react';
-import { Play, ListPlus, Radio, Heart, Download, ChevronRight, User, Disc3, ListMusic, Plus, Info } from 'lucide-react';
+import { Play, ListPlus, Radio, Heart, Download, ChevronRight, User, Disc3, ListMusic, Plus, Info, Sparkles } from 'lucide-react';
 import LastfmIcon from './LastfmIcon';
+import StarRating from './StarRating';
 import { lastfmLoveTrack, lastfmUnloveTrack } from '../api/lastfm';
 import { usePlayerStore, Track, songToTrack } from '../store/playerStore';
-import { SubsonicAlbum, SubsonicArtist, star, unstar, getSimilarSongs2, getTopSongs, buildDownloadUrl, getAlbum, getPlaylists, getPlaylist, createPlaylist, updatePlaylist, SubsonicPlaylist } from '../api/subsonic';
+import { useShallow } from 'zustand/react/shallow';
+import { SubsonicAlbum, SubsonicArtist, star, unstar, getSimilarSongs2, getSimilarSongs, getTopSongs, buildDownloadUrl, getAlbum, getPlaylists, getPlaylist, createPlaylist, updatePlaylist, SubsonicPlaylist, setRating } from '../api/subsonic';
 import { useNavigate } from 'react-router-dom';
 import { useAuthStore } from '../store/authStore';
 import { useDownloadModalStore } from '../store/downloadModalStore';
 import { usePlaylistStore } from '../store/playlistStore';
 import { open } from '@tauri-apps/plugin-shell';
-import { writeFile } from '@tauri-apps/plugin-fs';
 import { join } from '@tauri-apps/api/path';
+import { invoke } from '@tauri-apps/api/core';
+import { useZipDownloadStore } from '../store/zipDownloadStore';
 import { useTranslation } from 'react-i18next';
+import { showToast } from '../utils/toast';
 
 function sanitizeFilename(name: string): string {
   return name
@@ -21,6 +25,16 @@ function sanitizeFilename(name: string): string {
     .substring(0, 200) || 'download';
 }
 
+/** Fisher-Yates in-place shuffle — returns a new array, does not mutate the input. */
+function shuffleArray<T>(arr: T[]): T[] {
+  const result = [...arr];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+
 // ── Add-to-Playlist submenu ───────────────────────────────────────
 export function AddToPlaylistSubmenu({ songIds, onDone, dropDown }: { songIds: string[]; onDone: () => void; dropDown?: boolean }) {
   const { t } = useTranslation();
@@ -163,8 +177,26 @@ function AlbumToPlaylistSubmenu({ albumId, onDone }: { albumId: string; onDone:
 
 export default function ContextMenu() {
   const { t } = useTranslation();
-  const { contextMenu, closeContextMenu, playTrack, enqueue, queue, currentTrack, removeTrack, lastfmLovedCache, setLastfmLovedForSong, starredOverrides, setStarredOverride, openSongInfo } = usePlayerStore();
+  const { contextMenu, closeContextMenu, playTrack, enqueue, queue, currentTrack, removeTrack, lastfmLovedCache, setLastfmLovedForSong, starredOverrides, setStarredOverride, openSongInfo, userRatingOverrides, setUserRatingOverride } = usePlayerStore(
+    useShallow(s => ({
+      contextMenu: s.contextMenu,
+      closeContextMenu: s.closeContextMenu,
+      playTrack: s.playTrack,
+      enqueue: s.enqueue,
+      queue: s.queue,
+      currentTrack: s.currentTrack,
+      removeTrack: s.removeTrack,
+      lastfmLovedCache: s.lastfmLovedCache,
+      setLastfmLovedForSong: s.setLastfmLovedForSong,
+      starredOverrides: s.starredOverrides,
+      setStarredOverride: s.setStarredOverride,
+      openSongInfo: s.openSongInfo,
+      userRatingOverrides: s.userRatingOverrides,
+      setUserRatingOverride: s.setUserRatingOverride,
+    }))
+  );
   const auth = useAuthStore();
+  const audiomuseNavidromeEnabled = !!(auth.activeServerId && auth.audiomuseNavidromeByServer[auth.activeServerId]);
   const requestDownloadFolder = useDownloadModalStore(s => s.requestFolder);
   const navigate = useNavigate();
   const menuRef = useRef<HTMLDivElement>(null);
@@ -219,12 +251,19 @@ export default function ContextMenu() {
       }
       // Load radio queue in background — enqueueRadio replaces any pending radio
       // tracks so clicking "Start Radio" again never stacks duplicate batches.
+      // Shuffle so the follow-up tracks feel fresh instead of always being the
+      // same "Top 5" in the same order every time.
       try {
         const [similar, top] = await Promise.all([getSimilarSongs2(artistId), getTopSongs(artistName)]);
-        const radioTracks = [...top, ...similar]
-          .map(songToTrack)
-          .filter(t => t.id !== seedTrack.id)
-          .map(t => ({ ...t, radioAdded: true as const }));
+        // Keep artist top songs and similar-by-artist in two blocks (each shuffled), not one blended pile —
+        // otherwise this feels the same as Instant Mix (track-based similar only).
+        const topTracks = shuffleArray(
+          top.map(songToTrack).filter(t => t.id !== seedTrack.id).map(t => ({ ...t, radioAdded: true as const }))
+        );
+        const similarTracks = shuffleArray(
+          similar.map(songToTrack).filter(t => t.id !== seedTrack.id).map(t => ({ ...t, radioAdded: true as const }))
+        );
+        const radioTracks = [...topTracks, ...similarTracks];
         if (radioTracks.length > 0) usePlayerStore.getState().enqueueRadio(radioTracks, artistId);
       } catch (e) {
         console.error('Failed to load radio queue', e);
@@ -236,11 +275,17 @@ export default function ContextMenu() {
       const similarPromise = getSimilarSongs2(artistId).catch(() => [] as Awaited<ReturnType<typeof getSimilarSongs2>>);
       try {
         const top = await getTopSongs(artistName);
-        const topTracks = top.map(t => ({ ...songToTrack(t), radioAdded: true as const }));
+        // Shuffle so each Radio session starts from a different track rather
+        // than always kicking off with the #1 most-played song.
+        const topTracks = shuffleArray(
+          top.map(t => ({ ...songToTrack(t), radioAdded: true as const }))
+        );
         if (topTracks.length === 0) {
           // No local top songs — fall back to waiting for similar tracks
           const similar = await similarPromise;
-          const fallback = similar.map(t => ({ ...songToTrack(t), radioAdded: true as const }));
+          const fallback = shuffleArray(
+            similar.map(t => ({ ...songToTrack(t), radioAdded: true as const }))
+          );
           if (fallback.length === 0) return;
           const state = usePlayerStore.getState();
           if (state.currentTrack) {
@@ -251,22 +296,29 @@ export default function ContextMenu() {
           }
           return;
         }
-        // Start playback immediately from top songs
+        // Start playback from the first shuffled top track only.
+        // No other tracks are queued yet — positions 2+ will be filled
+        // exclusively by the similar-songs result below.
         const state = usePlayerStore.getState();
         if (state.currentTrack) {
-          state.enqueueRadio(topTracks, artistId);
+          state.enqueueRadio([topTracks[0]], artistId);
         } else {
           state.setRadioArtistId(artistId);
-          playTrack(topTracks[0], topTracks);
+          playTrack(topTracks[0], [topTracks[0]]);
         }
-        // Enrich with similar tracks in the background
+        // Populate positions 2+ from similar songs only — never from the
+        // remaining top tracks.  Mixing in topTracks.slice(1) meant that when
+        // getSimilarSongs2 returned nothing (no Last.fm, small library, etc.)
+        // the queue fell back to the same top-4 the user just heard.
+        // If similarTracks is also empty, the proactive top-up in next()
+        // will refill the queue when the first track nears its end.
         similarPromise.then(similar => {
-          const similarTracks = similar
-            .map(t => ({ ...songToTrack(t), radioAdded: true as const }))
-            .filter(t => !topTracks.some(top => top.id === t.id));
+          const similarTracks = shuffleArray(
+            similar
+              .map(t => ({ ...songToTrack(t), radioAdded: true as const }))
+              .filter(t => t.id !== topTracks[0].id)
+          );
           if (similarTracks.length === 0) return;
-          // Collect pending (upcoming) radio tracks so enqueueRadio re-inserts them
-          // together with the new similar tracks rather than losing them.
           const { queue, queueIndex } = usePlayerStore.getState();
           const pendingRadio = queue.slice(queueIndex + 1).filter(t => t.radioAdded);
           usePlayerStore.getState().enqueueRadio([...pendingRadio, ...similarTracks], artistId);
@@ -277,20 +329,50 @@ export default function ContextMenu() {
     }
   };
 
-  const downloadAlbum = async (albumName: string, albumId: string) => {
+  const startInstantMix = async (song: Track) => {
+    const state = usePlayerStore.getState();
+    if (state.currentTrack?.id === song.id) {
+      if (!state.isPlaying) state.resume();
+    } else {
+      playTrack(song, [song]);
+    }
+    const serverId = useAuthStore.getState().activeServerId;
     try {
-      const folder = auth.downloadFolder || await requestDownloadFolder();
-      if (!folder) return;
-
-      const url = buildDownloadUrl(albumId);
-      const response = await fetch(url);
-      if (!response.ok) throw new Error(`HTTP ${response.status}`);
-      const blob = await response.blob();
-      const buffer = await blob.arrayBuffer();
-      const path = await join(folder, `${sanitizeFilename(albumName)}.zip`);
-      await writeFile(path, new Uint8Array(buffer));
+      const similar = await getSimilarSongs(song.id, 50);
+      if (serverId) useAuthStore.getState().setAudiomuseNavidromeIssue(serverId, false);
+      const shuffled = shuffleArray(
+        similar
+          .filter(s => s.id !== song.id)
+          .map(s => ({ ...songToTrack(s), radioAdded: true as const }))
+      );
+      if (shuffled.length > 0) {
+        const aid = song.artistId?.trim() || undefined;
+        usePlayerStore.getState().enqueueRadio(shuffled, aid);
+      }
     } catch (e) {
-      console.error('Download failed:', e);
+      console.error('Instant mix failed', e);
+      if (serverId) useAuthStore.getState().setAudiomuseNavidromeIssue(serverId, true);
+      showToast(t('contextMenu.instantMixFailed'), 5000, 'error');
+    }
+  };
+
+  const downloadAlbum = async (albumName: string, albumId: string) => {
+    const folder = auth.downloadFolder || await requestDownloadFolder();
+    if (!folder) return;
+
+    const filename = `${sanitizeFilename(albumName)}.zip`;
+    const destPath = await join(folder, filename);
+    const url = buildDownloadUrl(albumId);
+    const id = crypto.randomUUID();
+
+    const { start, complete, fail } = useZipDownloadStore.getState();
+    start(id, filename);
+    try {
+      await invoke('download_zip', { id, url, destPath });
+      complete(id);
+    } catch (e) {
+      fail(id);
+      console.error('ZIP download failed:', e);
     }
   };
 
@@ -357,6 +439,11 @@ export default function ContextMenu() {
               <div className="context-menu-item" onClick={() => handleAction(() => startRadio(song.artistId ?? song.artist, song.artist, song))}>
                 <Radio size={14} /> {t('contextMenu.startRadio')}
               </div>
+              {audiomuseNavidromeEnabled && (
+                <div className="context-menu-item" onClick={() => handleAction(() => startInstantMix(song))}>
+                  <Sparkles size={14} /> {t('contextMenu.instantMix')}
+                </div>
+              )}
               <div className="context-menu-item" onClick={() => handleAction(() => {
                 const starred = isStarred(song.id, song.starred);
                 setStarredOverride(song.id, !starred);
@@ -381,6 +468,13 @@ export default function ContextMenu() {
                 );
               })()}
               <div className="context-menu-divider" />
+              <div className="context-menu-rating-row" onClick={e => e.stopPropagation()}>
+                <StarRating
+                  value={userRatingOverrides[song.id] ?? song.userRating ?? 0}
+                  onChange={r => { setUserRatingOverride(song.id, r); setRating(song.id, r).catch(() => {}); }}
+                  ariaLabel={t('albumDetail.ratingLabel')}
+                />
+              </div>
               <div className="context-menu-item" onClick={() => handleAction(() => openSongInfo(song.id))}>
                 <Info size={14} /> {t('contextMenu.songInfo')}
               </div>
@@ -500,7 +594,19 @@ export default function ContextMenu() {
               <div className="context-menu-item" onClick={() => handleAction(() => startRadio(song.artistId ?? song.artist, song.artist, song))}>
                 <Radio size={14} /> {t('contextMenu.startRadio')}
               </div>
+              {audiomuseNavidromeEnabled && (
+                <div className="context-menu-item" onClick={() => handleAction(() => startInstantMix(song))}>
+                  <Sparkles size={14} /> {t('contextMenu.instantMix')}
+                </div>
+              )}
               <div className="context-menu-divider" />
+              <div className="context-menu-rating-row" onClick={e => e.stopPropagation()}>
+                <StarRating
+                  value={userRatingOverrides[song.id] ?? song.userRating ?? 0}
+                  onChange={r => { setUserRatingOverride(song.id, r); setRating(song.id, r).catch(() => {}); }}
+                  ariaLabel={t('albumDetail.ratingLabel')}
+                />
+              </div>
               <div className="context-menu-item" onClick={() => handleAction(() => openSongInfo(song.id))}>
                 <Info size={14} /> {t('contextMenu.songInfo')}
               </div>

src/components/CustomSelect.tsx

@@ -25,15 +25,14 @@ export default function CustomSelect({ value, options, onChange, className = '',
 
   const selected = options.find(o => o.value === value);
 
-  useLayoutEffect(() => {
-    if (!open || !triggerRef.current) return;
+  const updateDropStyle = () => {
+    if (!triggerRef.current) return;
     const rect = triggerRef.current.getBoundingClientRect();
     const MARGIN = 6;
     const maxH = 240;
     const spaceBelow = window.innerHeight - rect.bottom - MARGIN;
     const spaceAbove = rect.top - MARGIN;
     const useAbove = spaceBelow < 80 && spaceAbove > spaceBelow;
-
     setDropStyle({
       position: 'fixed',
       left: rect.left,
@@ -44,6 +43,17 @@ export default function CustomSelect({ value, options, onChange, className = '',
       maxHeight: Math.min(maxH, useAbove ? spaceAbove : spaceBelow),
       zIndex: 99998,
     });
+  };
+
+  useLayoutEffect(() => {
+    if (!open) return;
+    updateDropStyle();
+  }, [open]);
+
+  useEffect(() => {
+    if (!open) return;
+    window.addEventListener('scroll', updateDropStyle, true);
+    return () => window.removeEventListener('scroll', updateDropStyle, true);
   }, [open]);
 
   useEffect(() => {

src/components/FullscreenPlayer.tsx

@@ -7,6 +7,7 @@ import { usePlayerStore } from '../store/playerStore';
 import { buildCoverArtUrl, coverArtCacheKey, getArtistInfo, star, unstar } from '../api/subsonic';
 import { useCachedUrl } from './CachedImage';
 import { getCachedUrl } from '../utils/imageCache';
+import { extractCoverColors } from '../utils/dynamicColors';
 import { useTranslation } from 'react-i18next';
 import { useLyrics } from '../hooks/useLyrics';
 import { useAuthStore } from '../store/authStore';
@@ -191,34 +192,50 @@ const FsPortrait = memo(function FsPortrait({ url }: { url: string }) {
   );
 });
 
-// ─── Full-width seekbar (isolated — re-renders every tick) ────────────────────
+// ─── Full-width seekbar — imperative DOM updates, zero React re-renders on tick ─
 const FsSeekbar = memo(function FsSeekbar({ duration }: { duration: number }) {
-  const progress    = usePlayerStore(s => s.progress);
-  const buffered    = usePlayerStore(s => s.buffered);
-  const currentTime = usePlayerStore(s => s.currentTime);
   const seek        = usePlayerStore(s => s.seek);
+  const timeRef     = useRef<HTMLSpanElement>(null);
+  const playedRef   = useRef<HTMLDivElement>(null);
+  const bufRef      = useRef<HTMLDivElement>(null);
+  const inputRef    = useRef<HTMLInputElement>(null);
+
+  useEffect(() => {
+    const s = usePlayerStore.getState();
+    const pct = s.progress * 100;
+    if (timeRef.current)   timeRef.current.textContent  = formatTime(s.currentTime);
+    if (playedRef.current) playedRef.current.style.width = `${pct}%`;
+    if (bufRef.current)    bufRef.current.style.width    = `${Math.max(pct, s.buffered * 100)}%`;
+    if (inputRef.current)  inputRef.current.value        = String(s.progress);
+
+    return usePlayerStore.subscribe(state => {
+      const p = state.progress * 100;
+      if (timeRef.current)   timeRef.current.textContent  = formatTime(state.currentTime);
+      if (playedRef.current) playedRef.current.style.width = `${p}%`;
+      if (bufRef.current)    bufRef.current.style.width    = `${Math.max(p, state.buffered * 100)}%`;
+      if (inputRef.current)  inputRef.current.value        = String(state.progress);
+    });
+  }, []);
 
   const handleSeek = useCallback(
     (e: React.ChangeEvent<HTMLInputElement>) => seek(parseFloat(e.target.value)),
     [seek]
   );
 
-  const pct = progress * 100;
-  const buf = Math.max(pct, buffered * 100);
-
   return (
     <div className="fs-seekbar-wrap">
       <div className="fs-seekbar-times">
-        <span>{formatTime(currentTime)}</span>
+        <span ref={timeRef} />
         <span>{formatTime(duration)}</span>
       </div>
       <div className="fs-seekbar">
         <div className="fs-seekbar-bg" />
-        <div className="fs-seekbar-buf" style={{ width: `${buf}%` }} />
-        <div className="fs-seekbar-played" style={{ width: `${pct}%` }} />
+        <div className="fs-seekbar-buf" ref={bufRef} />
+        <div className="fs-seekbar-played" ref={playedRef} />
         <input
+          ref={inputRef}
           type="range" min={0} max={1} step={0.001}
-          value={progress}
+          defaultValue={0}
           onChange={handleSeek}
           aria-label="seek"
         />
@@ -244,6 +261,10 @@ interface FullscreenPlayerProps {
   onClose: () => void;
 }
 
+// Module-level cache: artKey → accent color string.
+// Survives track changes so same-album songs reuse the extracted color instantly.
+const coverAccentCache = new Map<string, string>();
+
 export default function FullscreenPlayer({ onClose }: FullscreenPlayerProps) {
   const { t } = useTranslation();
   const currentTrack       = usePlayerStore(s => s.currentTrack);
@@ -284,6 +305,42 @@ export default function FullscreenPlayer({ onClose }: FullscreenPlayerProps) {
   // `false` = no fetchUrl fallback — prevents double crossfade (fetchUrl → blobUrl).
   const resolvedCoverUrl = useCachedUrl(coverUrl, coverKey, false);
 
+  // Dynamic accent color extracted from the current album cover.
+  // Applied as --dynamic-fs-accent on the root element so it inherits to all
+  // children; CSS rules use var(--dynamic-fs-accent, var(--accent)) as fallback.
+  // Reset to null on track change so the previous color doesn't linger while
+  // the new one is being extracted.
+  const [dynamicAccent, setDynamicAccent] = useState<string | null>(null);
+
+  // On cover change: hit cache for instant result, or fetch → extract → cache.
+  // Cache hit avoids re-fetching for same-album tracks. Reset only when uncached.
+  useEffect(() => {
+    if (!artKey || !artUrl) { setDynamicAccent(null); return; }
+    const cached = coverAccentCache.get(artKey);
+    if (cached) { setDynamicAccent(cached); return; }
+    // No cache hit — keep the previous color visible until extraction completes.
+    let cancelled = false;
+    let blobUrl = '';
+    (async () => {
+      try {
+        const resp = await fetch(artUrl);
+        if (cancelled) return;
+        const blob = await resp.blob();
+        if (cancelled) return;
+        blobUrl = URL.createObjectURL(blob);
+        const colors = await extractCoverColors(blobUrl);
+        if (cancelled) return;
+        if (colors.accent) {
+          coverAccentCache.set(artKey, colors.accent);
+          setDynamicAccent(colors.accent);
+        }
+      } catch { /* ignore */ } finally {
+        if (blobUrl) URL.revokeObjectURL(blobUrl);
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [artKey]);
+
   // Artist image → portrait on right. Falls back to cover art.
   const [artistBgUrl, setArtistBgUrl] = useState<string>('');
   useEffect(() => {
@@ -362,6 +419,7 @@ export default function FullscreenPlayer({ onClose }: FullscreenPlayerProps) {
       aria-label={t('player.fullscreen')}
       data-idle={isIdle}
       onMouseMove={handleMouseMove}
+      style={dynamicAccent ? { '--dynamic-fs-accent': dynamicAccent } as React.CSSProperties : undefined}
     >
 
       {/* Layer 0 — animated dark mesh gradient (real divs = will-change possible) */}
@@ -445,7 +503,7 @@ export default function FullscreenPlayer({ onClose }: FullscreenPlayerProps) {
             onClick={() => useAuthStore.getState().setShowFullscreenLyrics(!showFullscreenLyrics)}
             aria-label={t('player.fsLyricsToggle')}
             data-tooltip={t('player.fsLyricsToggle')}
-            style={{ color: showFullscreenLyrics ? 'var(--accent)' : 'rgba(255,255,255,0.35)' }}
+            style={{ color: showFullscreenLyrics ? (dynamicAccent ?? 'var(--accent)') : 'rgba(255,255,255,0.35)' }}
           >
             <MicVocal size={14} />
           </button>

src/components/Hero.tsx

@@ -8,8 +8,12 @@ import { useTranslation } from 'react-i18next';
 import { playAlbum } from '../utils/playAlbum';
 import { useIsMobile } from '../hooks/useIsMobile';
 import { useAuthStore } from '../store/authStore';
+import { filterAlbumsByMixRatings, getMixMinRatingsConfigFromAuth } from '../utils/mixRatingFilter';
 
 const INTERVAL_MS = 10000;
+const HERO_ALBUM_COUNT = 8;
+/** Larger pool when mix rating filter is on so we can still fill the hero strip. */
+const HERO_RANDOM_POOL = 32;
 
 // Crossfading background — same layer pattern as FullscreenPlayer
 function HeroBg({ url }: { url: string }) {
@@ -36,7 +40,6 @@ function HeroBg({ url }: { url: string }) {
           style={{
             backgroundImage: `url(${layer.url})`,
             opacity: layer.visible ? 1 : 0,
-            filter: layer.visible ? 'blur(0px)' : 'blur(18px)',
           }}
           aria-hidden="true"
         />
@@ -54,14 +57,33 @@ export default function Hero({ albums: albumsProp }: HeroProps = {}) {
   const navigate = useNavigate();
   const isMobile = useIsMobile();
   const musicLibraryFilterVersion = useAuthStore(s => s.musicLibraryFilterVersion);
+  const mixMinRatingFilterEnabled = useAuthStore(s => s.mixMinRatingFilterEnabled);
+  const mixMinRatingAlbum = useAuthStore(s => s.mixMinRatingAlbum);
+  const mixMinRatingArtist = useAuthStore(s => s.mixMinRatingArtist);
   const [albums, setAlbums] = useState<SubsonicAlbum[]>([]);
   const [activeIdx, setActiveIdx] = useState(0);
   const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
 
   useEffect(() => {
     if (albumsProp?.length) { setAlbums(albumsProp); return; }
-    getRandomAlbums(8).then(a => { if (a.length) setAlbums(a); }).catch(() => {});
-  }, [albumsProp, musicLibraryFilterVersion]);
+    const cfg = { ...getMixMinRatingsConfigFromAuth(), minSong: 0 };
+    const albumMix = cfg.enabled && (cfg.minAlbum > 0 || cfg.minArtist > 0);
+    const pool = albumMix ? HERO_RANDOM_POOL : HERO_ALBUM_COUNT;
+    getRandomAlbums(pool)
+      .then(async raw => {
+        const list = albumMix
+          ? (await filterAlbumsByMixRatings(raw, cfg)).slice(0, HERO_ALBUM_COUNT)
+          : raw;
+        setAlbums(list);
+      })
+      .catch(() => {});
+  }, [
+    albumsProp,
+    musicLibraryFilterVersion,
+    mixMinRatingFilterEnabled,
+    mixMinRatingAlbum,
+    mixMinRatingArtist,
+  ]);
 
   // Start / restart auto-advance timer
   const startTimer = useCallback((len: number) => {

src/components/LiveSearch.tsx

@@ -1,6 +1,6 @@
 import React, { useState, useEffect, useRef, useCallback } from 'react';
 import { useNavigate } from 'react-router-dom';
-import { Search, Disc3, Users, Music, SlidersHorizontal } from 'lucide-react';
+import { Search, Disc3, Users, Music, SlidersVertical, TextSearch } from 'lucide-react';
 import { search, SearchResults, buildCoverArtUrl } from '../api/subsonic';
 import { usePlayerStore, songToTrack } from '../store/playerStore';
 import { useAuthStore } from '../store/authStore';
@@ -126,7 +126,7 @@ export default function LiveSearch() {
           data-tooltip-pos="bottom"
           aria-label={t('search.advanced')}
         >
-          <SlidersHorizontal size={14} />
+          <TextSearch size={14} />
         </button>
       </div>
 

src/components/LyricsPane.tsx

@@ -57,7 +57,9 @@ export default function LyricsPane({ currentTrack }: Props) {
     ? t('player.lyricsSourceServer')
     : source === 'lrclib'
       ? t('player.lyricsSourceLrclib')
-      : null;
+      : source === 'netease'
+        ? t('player.lyricsSourceNetease')
+        : null;
 
   return (
     <div className="lyrics-pane">

src/components/NowPlayingDropdown.tsx

@@ -36,16 +36,14 @@ export default function NowPlayingDropdown() {
     });
   };
 
-  // Poll in background so the badge stays current without opening the dropdown
+  // Poll only while the dropdown is open AND the page is visible.
   useEffect(() => {
+    if (!isOpen) return;
     fetchNowPlaying();
-    const id = setInterval(fetchNowPlaying, 10000);
+    const id = setInterval(() => {
+      if (document.visibilityState === 'visible') fetchNowPlaying();
+    }, 10000);
     return () => clearInterval(id);
-  }, []);
-
-  // Refresh immediately when dropdown is opened
-  useEffect(() => {
-    if (isOpen) fetchNowPlaying();
   }, [isOpen]);
 
   // Click outside to close

src/components/PlayerBar.tsx

@@ -1,20 +1,23 @@
-import React, { useCallback, useMemo, useState } from 'react';
+import React, { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { createPortal } from 'react-dom';
 import {
   Play, Pause, SkipBack, SkipForward, Volume2, VolumeX, Music,
-  Square, Repeat, Repeat1, Maximize2, SlidersHorizontal, X, Heart, MicVocal, Cast
+  Square, Repeat, Repeat1, Maximize2, SlidersVertical, X, Heart, Cast
 } from 'lucide-react';
 import { usePlayerStore } from '../store/playerStore';
+import { useShallow } from 'zustand/react/shallow';
 import { useAuthStore } from '../store/authStore';
-import { buildCoverArtUrl, coverArtCacheKey, star, unstar } from '../api/subsonic';
+import { buildCoverArtUrl, coverArtCacheKey, star, unstar, setRating } from '../api/subsonic';
 import CachedImage from './CachedImage';
 import WaveformSeek from './WaveformSeek';
 import Equalizer from './Equalizer';
+import StarRating from './StarRating';
 import { useTranslation } from 'react-i18next';
 import { useNavigate } from 'react-router-dom';
 import { useLyricsStore } from '../store/lyricsStore';
 import MarqueeText from './MarqueeText';
 import LastfmIcon from './LastfmIcon';
+import { useRadioMetadata } from '../hooks/useRadioMetadata';
 
 function formatTime(seconds: number): string {
   if (!seconds || isNaN(seconds)) return '0:00';
@@ -23,6 +26,21 @@ function formatTime(seconds: number): string {
   return `${m}:${s.toString().padStart(2, '0')}`;
 }
 
+// Renders the playback clock without ever causing PlayerBar to re-render.
+// Updates the DOM directly via an imperative store subscription.
+const PlaybackTime = memo(function PlaybackTime({ className }: { className?: string }) {
+  const spanRef = useRef<HTMLSpanElement>(null);
+  useEffect(() => {
+    if (spanRef.current) {
+      spanRef.current.textContent = formatTime(usePlayerStore.getState().currentTime);
+    }
+    return usePlayerStore.subscribe(state => {
+      if (spanRef.current) spanRef.current.textContent = formatTime(state.currentTime);
+    });
+  }, []);
+  return <span className={className} ref={spanRef} />;
+});
+
 export default function PlayerBar() {
   const { t } = useTranslation();
   const navigate = useNavigate();
@@ -30,18 +48,44 @@ export default function PlayerBar() {
   const [showVolPct, setShowVolPct] = useState(false);
   const showLyrics   = useLyricsStore(s => s.showLyrics);
   const activeTab    = useLyricsStore(s => s.activeTab);
+  // currentTime is intentionally excluded — PlaybackTime handles it via direct DOM update.
   const {
-    currentTrack, currentRadio, isPlaying, currentTime, volume,
+    currentTrack, currentRadio, isPlaying, volume,
     togglePlay, next, previous, setVolume,
     stop, toggleRepeat, repeatMode, toggleFullscreen,
     lastfmLoved, toggleLastfmLove,
     isQueueVisible, toggleQueue,
     starredOverrides, setStarredOverride,
-  } = usePlayerStore();
+    userRatingOverrides, setUserRatingOverride,
+  } = usePlayerStore(useShallow(s => ({
+    currentTrack: s.currentTrack,
+    currentRadio: s.currentRadio,
+    isPlaying: s.isPlaying,
+    volume: s.volume,
+    togglePlay: s.togglePlay,
+    next: s.next,
+    previous: s.previous,
+    setVolume: s.setVolume,
+    stop: s.stop,
+    toggleRepeat: s.toggleRepeat,
+    repeatMode: s.repeatMode,
+    toggleFullscreen: s.toggleFullscreen,
+    lastfmLoved: s.lastfmLoved,
+    toggleLastfmLove: s.toggleLastfmLove,
+    isQueueVisible: s.isQueueVisible,
+    toggleQueue: s.toggleQueue,
+    starredOverrides: s.starredOverrides,
+    setStarredOverride: s.setStarredOverride,
+    userRatingOverrides: s.userRatingOverrides,
+    setUserRatingOverride: s.setUserRatingOverride,
+  })));
   const { lastfmSessionKey } = useAuthStore();
 
   const isRadio = !!currentRadio;
 
+  // Radio metadata (ICY or AzuraCast) — only active while a radio station is playing.
+  const radioMeta = useRadioMetadata(currentRadio ?? null);
+
   const isStarred = currentTrack
     ? (currentTrack.id in starredOverrides ? starredOverrides[currentTrack.id] : !!currentTrack.starred)
     : false;
@@ -127,17 +171,40 @@ export default function PlayerBar() {
         </div>
         <div className="player-track-meta">
           <MarqueeText
-            text={isRadio ? (currentRadio?.name ?? '—') : (currentTrack?.title ?? t('player.noTitle'))}
+            text={isRadio
+              ? (radioMeta.currentTitle
+                  ? (radioMeta.currentArtist
+                      ? `${radioMeta.currentArtist} — ${radioMeta.currentTitle}`
+                      : radioMeta.currentTitle)
+                  : (currentRadio?.name ?? '—'))
+              : (currentTrack?.title ?? t('player.noTitle'))}
             className="player-track-name"
             style={{ cursor: !isRadio && currentTrack?.albumId ? 'pointer' : 'default' }}
             onClick={() => !isRadio && currentTrack?.albumId && navigate(`/album/${currentTrack.albumId}`)}
           />
           <MarqueeText
-            text={isRadio ? t('radio.liveStream') : (currentTrack?.artist ?? '—')}
+            text={isRadio
+              ? (radioMeta.currentTitle && currentRadio?.name
+                  ? currentRadio.name
+                  : t('radio.liveStream'))
+              : (currentTrack?.artist ?? '—')}
             className="player-track-artist"
             style={{ cursor: !isRadio && currentTrack?.artistId ? 'pointer' : 'default' }}
             onClick={() => !isRadio && currentTrack?.artistId && navigate(`/artist/${currentTrack.artistId}`)}
           />
+          {currentTrack && !isRadio && (
+            <StarRating
+              value={userRatingOverrides[currentTrack.id] ?? currentTrack.userRating ?? 0}
+              onChange={r => { setUserRatingOverride(currentTrack.id, r); setRating(currentTrack.id, r).catch(() => {}); }}
+              className="player-track-rating"
+              ariaLabel={t('albumDetail.ratingLabel')}
+            />
+          )}
+          {isRadio && radioMeta.listeners != null && (
+            <span className="player-radio-listeners">
+              {t('radio.listenerCount', { count: radioMeta.listeners })}
+            </span>
+          )}
         </div>
         {currentTrack && !isRadio && (
           <button
@@ -197,15 +264,32 @@ export default function PlayerBar() {
       <div className="player-waveform-section">
         {isRadio ? (
           <>
-            <span className="player-time">{formatTime(currentTime)}</span>
-            <div className="player-waveform-wrap" style={{ display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
-              <span className="radio-live-badge">{t('radio.live')}</span>
-            </div>
-            <span className="player-time" style={{ opacity: 0 }}>0:00</span>
+            {radioMeta.source === 'azuracast' && radioMeta.elapsed != null && radioMeta.duration != null && radioMeta.duration > 0 ? (
+              <>
+                <span className="player-time">{formatTime(radioMeta.elapsed)}</span>
+                <div className="player-waveform-wrap">
+                  <div className="radio-progress-bar">
+                    <div
+                      className="radio-progress-fill"
+                      style={{ width: `${Math.min(100, (radioMeta.elapsed / radioMeta.duration) * 100)}%` }}
+                    />
+                  </div>
+                </div>
+                <span className="player-time">{formatTime(radioMeta.duration)}</span>
+              </>
+            ) : (
+              <>
+                <PlaybackTime className="player-time" />
+                <div className="player-waveform-wrap" style={{ display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+                  <span className="radio-live-badge">{t('radio.live')}</span>
+                </div>
+                <span className="player-time" style={{ opacity: 0 }}>0:00</span>
+              </>
+            )}
           </>
         ) : (
           <>
-            <span className="player-time">{formatTime(currentTime)}</span>
+            <PlaybackTime className="player-time" />
             <div className="player-waveform-wrap">
               <WaveformSeek trackId={currentTrack?.id} />
             </div>
@@ -214,16 +298,6 @@ export default function PlayerBar() {
         )}
       </div>
 
-      {/* Lyrics Button */}
-      <button
-        className={`player-btn player-btn-sm ${activeTab === 'lyrics' && isQueueVisible ? 'active' : ''}`}
-        onClick={() => { if (!isQueueVisible) toggleQueue(); showLyrics(); }}
-        aria-label={t('player.lyrics')}
-        data-tooltip={t('player.lyrics')}
-      >
-        <MicVocal size={15} />
-      </button>
-
       {/* EQ Button */}
       <button
         className={`player-btn player-btn-sm player-eq-btn ${eqOpen ? 'active' : ''}`}
@@ -231,7 +305,7 @@ export default function PlayerBar() {
         aria-label="Equalizer"
         data-tooltip="Equalizer"
       >
-        <SlidersHorizontal size={15} />
+        <SlidersVertical size={15} />
       </button>
 
       {/* Volume */}

src/components/QueuePanel.tsx

@@ -214,6 +214,7 @@ export default function QueuePanel() {
   const queue = usePlayerStore(s => s.queue);
   const queueIndex = usePlayerStore(s => s.queueIndex);
   const currentTrack = usePlayerStore(s => s.currentTrack);
+  const userRatingOverrides = usePlayerStore(s => s.userRatingOverrides);
   const currentCoverFetchUrl = useMemo(
     () => currentTrack?.coverArt ? buildCoverArtUrl(currentTrack.coverArt, 128) : '',
     [currentTrack?.coverArt]
@@ -447,7 +448,7 @@ export default function QueuePanel() {
               {currentTrack.year && (
                 <div className="queue-current-sub">{currentTrack.year}</div>
               )}
-              {renderStars(currentTrack.userRating)}
+              {renderStars(userRatingOverrides[currentTrack.id] ?? currentTrack.userRating)}
             </div>
           </div>
         </div>

src/components/Sidebar.tsx

@@ -2,6 +2,7 @@ import React, { useState, useRef, useLayoutEffect, useEffect, useCallback } from
 import { createPortal } from 'react-dom';
 import { usePlayerStore } from '../store/playerStore';
 import { useOfflineStore } from '../store/offlineStore';
+import { useOfflineJobStore } from '../store/offlineJobStore';
 import { useAuthStore } from '../store/authStore';
 import { useSidebarStore } from '../store/sidebarStore';
 import { NavLink } from 'react-router-dom';
@@ -9,7 +10,7 @@ import { useTranslation } from 'react-i18next';
 import {
   Disc3, Users, Music4, Radio, Settings, Heart, BarChart3, Shuffle,
   PanelLeftClose, PanelLeft, HelpCircle, Dices, AudioLines, HardDriveDownload, Tags, ListMusic, Cast,
-  ChevronDown, Check, Music2,
+  ChevronDown, Check, Music2, TrendingUp, FolderOpen, X,
 } from 'lucide-react';
 import PsysonicLogo from './PsysonicLogo';
 import PSmallLogo from './PSmallLogo';
@@ -24,10 +25,12 @@ export const ALL_NAV_ITEMS: Record<string, { icon: React.ElementType; labelKey:
   artists:      { icon: Users,      labelKey: 'sidebar.artists',      to: '/artists',       section: 'library' },
   genres:       { icon: Tags,       labelKey: 'sidebar.genres',       to: '/genres',        section: 'library' },
   randomMix:    { icon: Shuffle,    labelKey: 'sidebar.randomMix',    to: '/random-mix',    section: 'library' },
-  favorites:    { icon: Heart,      labelKey: 'sidebar.favorites',    to: '/favorites',     section: 'library' },
-  playlists:    { icon: ListMusic,  labelKey: 'sidebar.playlists',    to: '/playlists',     section: 'library' },
-  radio:        { icon: Cast,       labelKey: 'sidebar.radio',         to: '/radio',         section: 'library' },
-  statistics:   { icon: BarChart3,  labelKey: 'sidebar.statistics',   to: '/statistics',    section: 'system'  },
+  favorites:    { icon: Heart,       labelKey: 'sidebar.favorites',    to: '/favorites',      section: 'library' },
+  playlists:    { icon: ListMusic,   labelKey: 'sidebar.playlists',    to: '/playlists',      section: 'library' },
+  mostPlayed:   { icon: TrendingUp,  labelKey: 'sidebar.mostPlayed',   to: '/most-played',    section: 'library' },
+  radio:        { icon: Cast,        labelKey: 'sidebar.radio',        to: '/radio',          section: 'library' },
+  folderBrowser: { icon: FolderOpen,  labelKey: 'sidebar.folderBrowser', to: '/folders',        section: 'library' },
+  statistics:   { icon: BarChart3,   labelKey: 'sidebar.statistics',   to: '/statistics',     section: 'system'  },
   help:         { icon: HelpCircle, labelKey: 'sidebar.help',         to: '/help',          section: 'system'  },
 };
 
@@ -42,7 +45,8 @@ export default function Sidebar({
   const { t } = useTranslation();
   const isPlaying   = usePlayerStore(s => s.isPlaying);
   const currentTrack = usePlayerStore(s => s.currentTrack);
-  const offlineJobs = useOfflineStore(s => s.jobs);
+  const offlineJobs = useOfflineJobStore(s => s.jobs);
+  const cancelAllDownloads = useOfflineJobStore(s => s.cancelAllDownloads);
   const activeJobs = offlineJobs.filter(j => j.status === 'queued' || j.status === 'downloading');
   const offlineAlbums = useOfflineStore(s => s.albums);
   const serverId = useAuthStore(s => s.activeServerId ?? '');
@@ -286,6 +290,15 @@ export default function Sidebar({
             {!isCollapsed && (
               <span>{t('sidebar.downloadingTracks', { n: activeJobs.length })}</span>
             )}
+            <button
+              className="sidebar-offline-cancel"
+              onClick={cancelAllDownloads}
+              data-tooltip={t('sidebar.cancelDownload')}
+              data-tooltip-pos="right"
+              aria-label={t('sidebar.cancelDownload')}
+            >
+              <X size={12} />
+            </button>
           </div>
         )}
       </nav>

src/components/SongInfoModal.tsx

@@ -2,6 +2,7 @@ import React, { useEffect, useState } from 'react';
 import { createPortal } from 'react-dom';
 import { X } from 'lucide-react';
 import { usePlayerStore } from '../store/playerStore';
+import { useShallow } from 'zustand/react/shallow';
 import { getSong, SubsonicSong } from '../api/subsonic';
 import { useTranslation } from 'react-i18next';
 
@@ -33,7 +34,9 @@ function Divider() {
 
 export default function SongInfoModal() {
   const { t } = useTranslation();
-  const { songInfoModal, closeSongInfo } = usePlayerStore();
+  const { songInfoModal, closeSongInfo } = usePlayerStore(
+    useShallow(s => ({ songInfoModal: s.songInfoModal, closeSongInfo: s.closeSongInfo }))
+  );
   const [song, setSong] = useState<SubsonicSong | null>(null);
   const [loading, setLoading] = useState(false);