An opt-in setting replaces the song title in the system media
controls with the current synced lyric line. Only the OS sees it:
the wrapper sits under the media session filter, so Last.fm,
Discord, widgets and Link keep the real title.
Lyrics come from the file and its .mlrc sidecar, never online.
Breaks of 3 s or more show the title, and the title changes at
most twice a second. Android shows lines only while the keyguard
is up and the screen is on; iOS cannot tell, so it shows them
while Mornye is in the background and restates the position first
so Now Playing does not jump back.
Smart Dither only adds dither when lowering bit depth, but it always used
plain TPDF. A new Use TPDF HP switch makes it use high-pass TPDF instead,
in the convert sheet (shown while Smart is selected) and for automatic
FLAC conversion of downloads (under Smart Dither, saved as
autoConvertSmartDitherHighPass). The native Android finalizer, the
Dart FFmpeg path and Mornye Link conversions all honor it; Link sends it
as ditherHighPass, which older desktops ignore. The switch is off by
default, so existing conversions do not change.
The explicit Triangular HP option is now labelled TPDF HP, next to TPDF.
An opt-in Files setting copies a download's animated cover into its
album folder as cover.mp4, so file managers and other players find it.
Only folders that hold one album get it: the folder is planned again
with a marked album name, and flat, artist, playlist and shared Singles
folders are skipped, as is a song kept in a folder other than the
planned one. An existing cover.mp4 is never replaced, for local files,
Android folder access and network storage alike; songs of one album
that finish together write it once.
The player, mini player and album headers now show a cover.mp4 found
beside a local song before the artwork saved for the album. Android
documents are found through a new findSafSibling call and copied into
app storage once per version, since the video player only opens files.
Saving a lyrics translation now covers every kind of lyrics:
- Plain lyrics can be translated on request. Each line's pronunciation
and translation show under it. Automatic translation stays synced-only.
- AI pronunciation is saved too, with its word timing, as x-romaji and
x-romaji-words tags next to the translation.
- A new .mlrc file next to the song keeps its lyrics with their
translation and pronunciation and leaves the audio file as it is. It is
UTF-8 LRC that starts with [x-mlrc:1]. Supplement tags are keyed by
line time, or by line index for lyrics without timing. TTML is written
as enhanced LRC with voices and backing vocals. The player reads it next
to local and Android document songs and lays it over the song's lyrics
by line text.
- AI Translation settings gain a Files section: Save To picks the song
file or a .mlrc file, and Save Automatically saves each shown
translation without a snackbar. TTML and plain lyrics always go to
.mlrc. Saving into the song file also refreshes an existing .mlrc.
- Android reads and writes the sidecar through new SAF calls, and the
.lrc sidecar write shares the same code.
Android failed the song on any media error message from the receiver,
even if the TV kept playing. The app then showed "TV could not play this
audio file", stopped following the position and stopped sending Pause.
Fail only when the receiver stops with an error, as the iOS and desktop
sender already does. Media errors now reach the app log with their reason
and code on every platform, so a failed seek can be traced.
Since player operations moved off the UI thread, create replied before
the event channel's main-thread registration ran. Dart listened to a
stream with no handler, lost the prepared event, and playback loaded
forever. Reply after the registration instead.
Tablets (shortest side at least 600dp) may use every orientation outside
the full player, and the activity starts with the user's rotation setting
on them. Phones and TV keep their existing rules.
Contributed by Keven Chantre in #807. Fixes#805.
- iOS: a Swift plugin drives the Rust sender on the existing cast
channels. A silent mixable loop keeps the app serving audio while a
session is connected. Audio output now opens the same sheet as
Android, with AirPlay and Bluetooth opening the system route picker.
- Desktop: CastOutput talks to the Rust sender through the backend
channel. Material shows a Cast button in the player bar that gives
way after the volume slider in narrow windows; the Mornye capsule
puts Cast in its volume popover.
- iOS and desktop pick receivers in a new app sheet that looks for
devices while open and connects on tap.
- Android keeps Google's sender and dialog, and now serves media from
the Rust server. The Dart CastMediaServer is removed.
Use SHA-256 names for Android library artwork and migrate stored Library paths in resumable pages. Preserve legacy files until saved references release them. Host fixtures reduce twelve repeated thumbnails to two files and keep shared bytes unchanged when one song changes artwork.
Keep descriptor metadata as a JSONObject through SAF enrichment and final scan publication. Preserve the string API for existing callers and use the typed result for CUE artwork too.
Read unchanged CUE FILE directives directly with an 8 KiB buffered reader instead of copying the entire sheet to temporary storage. Preserve BOM, quoted names, basename fallback, late directives and MediaStore retry behavior.
Evidence: 46 focused SAF JVM tests and 46 Dart scan tests pass. A 1.8 MB CUE fixture consumes at most 8 KiB when FILE appears first, and metadata remains the same object until one final serialization. Restoring either previous implementation fails its regression test. JVM module compilation uses unchanged-ABI generated bindings; no device build.
Install the crash handler immediately and read and commit session preferences on the existing recovery executor before inspecting the previous exit. Report readers retain their recovery wait and synchronous crash persistence is unchanged.
The JVM startup test calls the real initializer and rejects all preference I/O on its caller thread. It fails with the former synchronous initialization, then passes with the worker implementation.
Keep download snapshots as JSON across the Android channel and decode large progress payloads off the UI isolate while retaining event order and permissive empty-result behavior. Encode bounded small native data requests inline, with the existing pre-dispatch cancellation yield and background fallback for larger graphs.
Host tests verify zero encoder isolates for small requests, background decoding of large snapshots, cursor resets, stream cancellation, exact JSON and separate binary arguments. Restoring the old codec paths fails the corresponding isolate and event-loop probes.
Bump Library to v21 and History to v16, add album artist indexes, and remove six Library and three History indexes whose seeks are served by existing queue indexes. Keep the named file-path index for released readers and synchronize native schema checks.
Persist the iOS container migration marker in the database transaction, exclude current paths, and bound Library and CUE reads to 256 rows. Repeat opens read one marker row. Test rollback, path keys, bookmarked sources and downgrade/reupgrade compatibility.
Four alternating 15,000-row host write pairs reduced median batch time from 3364.773 ms to 2782.200 ms (17.3 percent). Native staging now takes the shared History schema version.
Poll cancellation while waiting for a SAF worker and cancel outstanding tasks. Preserve thread interruption and reject results returned after cancellation. Three focused JVM tests pass.
Setup only checked the audio permission from Android 13, so a phone that
already granted all-files access (or granted it in settings and came
back) stayed stuck on the storage step, and Grant Permission asked again.
Setup now treats all-files access as enough on Android 11 and later, and
rechecks it before requesting anything.
It also reads the Android API level from the app's own channel, falling
back to device_info, so the Android 17 steps still appear when full
device information is unavailable.
Add FLAC auto-conversion with maximum bit depth and sample rate in foreground and Android background downloads. Preserve lower source rates, artwork, metadata and output quality.
Keep 48 kHz available for mixed-source batch conversion and add 160 kbps to manual, batch and automatic conversion.
Validation: 122 Flutter tests and 26 Android JVM tests passed. Analysis of lib and test passed.
Supply GIT_COMMIT from Android Gradle and the iOS Flutter build phase so the existing About footer displays the revision without manual build flags. Preserve explicit defines and source archive builds.
Validation: 19 targeted tests passed, Android compiler define forwarding checked with automatic and explicit revisions, ShellCheck and Xcode project syntax checks passed, git diff --check clean.
On Android, the audio info sheet showed the default low-latency PCM rate,
bit depth and buffer as the output of a Bluetooth route, and computed
resampling from them. Android does not report the negotiated A2DP or LE
Audio codec format, so for Bluetooth, LE and hearing aid routes the sheet
now says so, labels the PCM values as system defaults, and shows no
resampling. The sheet also reads the route again when the app returns to
the foreground, so a route changed in Settings shows at once.
With FFmpegKit now loaded on the first Dart call, a download that
finalizes before any Dart FFmpeg use is the usual order. The finalizer's
complete-callback filter then read a null callback and forwarded to
nothing, and the plugin's later registration replaced the filter. If the
read and the write straddled the registration, the filter forwarded to
null until the process restarted.
The plugin now exposes ensureGlobalCallbacksRegistered(), which registers
the global callbacks on the calling thread (loading FFmpegKit if needed),
waits for a registration already in progress and throws a load failure
to its first caller. The background load uses it too, and the finalizer
calls it before wrapping, so the filter always wraps the plugin callback
and is never replaced. The finalizer runs on worker threads, so the main
thread still never waits for the load.
The host-JVM main looper stand-in is now a thread named main that the
tests post calls through, and replies are checked against it: draining
the waiting calls on the loader thread instead of posting them, removing
the registration lock, or making the new method a no-op each fail a
test. No startup cost change; the ST1 gain is unchanged.
audio_service kept every decoded cover in an LruCache sized one eighth
of the Java heap (16 to 64 MB) that only onDestroy emptied, so a long
shuffle session filled it after 8 to 15 covers and held it through
background playback. Its decode used a power-of-two sample size toward
512 px, so an 800 px Library thumbnail stayed 2.4 MiB and a 1000 px
cover 3.8 MiB, although the session only takes 512 px copies.
The service now keeps the current cover and the two before it
(RecentArtCache), and onTrimMemory at TRIM_MEMORY_RUNNING_LOW or above
(UI_HIDDEN and BACKGROUND on Android 14 and later) drops all but the
current one. Eviction never recycles, so the notification and session
keep what they show. Each decoded cover is scaled to 512 px with the
same createScaledBitmap call the session copy made, so the session's
512 px copies keep their pixels; the 256 px notification icon is now
scaled from 512 px (owner-approved).
Retained art goes from up to 16 to 64 MB to at most three 1 MiB
bitmaps, one after a trim. Recorded in MORNYE_PATCHES.md; JUnit
RecentArtCacheTest, and the instrumented MediaControlMetadataTest
covers the 512 px bound.
An unexpected runtime error between the open and the image check left
the descriptor open, so a binder thread of the cover provider could leak
it. The descriptor is now closed in a finally block whenever no image
type was found.
The car's queue view loads each queue item's icon URI in its own process,
so a local song's app-private file:// cover showed nothing there, while
its browse entry already shows the cover through the cover provider.
audio_service gains AudioServicePlugin.setQueueArtResolver (recorded in
MORNYE_PATCHES.md). raw2queue applies it to each QueueItem description
only; the item's MediaMetadataCompat, the metadata cache, the playing
item, the notification and the lock screen keep the original artwork.
A null answer, a resolver that throws, or no resolver keeps the
description as it was.
The app's resolver maps a file:// or plain absolute path that names a
cover directly in the provider's folders, read from the path alone with
the same per-folder name rules, to the provider URI its browse entry
gets, so the car's cache sees one URI per cover.
The cover folders also hold files that are not covers: `.source`
sidecars with the user's audio file paths and `.current` pointers next
to the covers, the regenerate marker, and staging files. Only the image
signature check kept them out. Each folder now also names its covers by
their endings (cover store `.image`; Library thumbnails `.jpg`, `.png`
and `.image`; embedded artwork `.jpg`), so those files are refused by
name before anything is opened.
The provider checked one open of the file and served another. It now
opens the resolved file once with O_NOFOLLOW (and O_CLOEXEC from API
27), checks that descriptor with fstat for a regular file and pread for
an image signature, and serves a dup of that same descriptor; getType
reads its type the same way. The signatures are written as byte values,
so the source stays ASCII.
Android Auto loads browse item artwork from the item's icon URI in its
own process, so it cannot open the app's private cover files and local
covers were left out of every browse list.
CoverContentProvider serves them as content://<applicationId>.covers/
<folder>/<file>. A car cannot hold a permission, so the provider is
exported, and in exchange it only reads: openFile accepts mode "r" only,
insert/update/delete throw, query lists nothing. CoverProviderFiles
resolves a URI to a file only when its path is an allowed folder name
and a plain file name, the canonical file sits directly in the
canonical folder (no "..", encoded "/" or symbolic link out), and it is
a regular file starting with a known image signature.
The allowed folders are the ones browse lists name: the cover store
(files/covers), Library thumbnails (files/library_covers) and embedded
artwork extracted from downloads (cache/embedded_cover_previews). The
covers channel hands Dart the authority and folder paths, registered on
the shared engine so a car-started engine has it too.
Scan thumbnails were named by a 32-bit djb2 hash of "path|size|mtime" (or
the document key) and an existing file was reused without checking its
source, so two songs whose keys collided showed one cover. The Android
document scan had its own copy of the same hash.
Thumbnails are now named cover_<first 128 bits of SHA-256 of the key>, in
Rust for every scan and through library_cover_slot for the Kotlin document
scan, so reuse by name is safe. Rows that name older files keep working;
those files are not looked up again and are pruned once unreferenced.
A forced rescan can touch a .regenerate marker in the cover folder:
thumbnails older than it are extracted again under the same name instead
of being reused, and the newer of a .jpg and .png sibling wins.
Albums, singles and playlists, online and in the Library, end with
"Suggested songs": up to ten songs like the ones above that the collection
does not hold yet, each with a preview, an add button and a click or tap
that downloads it. On a user playlist the add button adds the song there
and it leaves the suggestions; elsewhere it opens the playlist picker.
Phones list the songs as rows, desktop in the page's song table.
Suggestions come from a new optional extension method, getRelatedTracks,
which extensions declare with the relatedTracks capability: it takes up to
three of the collection's songs and returns songs in the shape of search
results. The extension most seeds came from is preferred so it can use
their IDs. Without such an extension, the first metadata provider is
searched by the collection's artists. A refresh button starts from other
songs, and loaded suggestions stay for ten minutes.
Offer cover and LRC export for accessible imported songs. Publish Android SAF sidecars beside the audio document without requiring download history, reuse cached artwork when needed, and clean temporary outputs on every exit path.
Validation: 36 Flutter tests, one Android SAF instrumentation test, scoped analysis, formatting checks, and git diff --check passed.
Publish all split tracks and their visibility rule atomically while preserving the original files and playlist rows. Keep the rule across rescans, restore originals when outputs leave the visible Library, and stabilize Android SAF identities and artwork caching.
Validation: 84 Flutter tests, 19 native Library tests, scoped analyzer, formatting checks, and Android Kotlin compilation passed.