feat(core,app,android,ios): play the dialogue, not the signs and songs

Anime releases often carry two subtitle tracks in one language, the
dialogue and a "Signs & Songs" track, and the second is as often as not
the one marked default or forced. mpv, picking by language, played it.

pstr_core::subtitles reads a track's name and forced flag for whether it
is the dialogue, and every client asks it once per file, after mpv has
made its own pick, whether to switch to a track in the same language
that is. A subtitle track the viewer chose by name stays, and subtitles
that are off stay off.

crates/pstr-android/src/lib.rs

@@ -27,6 +27,7 @@ use pstr_core::proton_drive_rs::ThumbnailType;
 use pstr_core::proton_sdk::api::HumanVerificationCredential;
 use pstr_core::proton_sdk::ids::{LinkId, VolumeId};
 use pstr_core::shares::AccountFolder;
+use pstr_core::subtitles::SubtitleTrack;
 use pstr_core::sync::WatchSync;
 use pstr_core::{
     Account, AccountStore, SecretStore, Share, ShareClient, ShareStore, SharedLibrary,
@@ -739,6 +740,38 @@ fn chapter_kind(role: ChapterRole) -> ChapterKind {
     }
 }
 
+/// One subtitle track as the player read it out of mpv's `track-list`.
+#[derive(Debug, Clone, uniffi::Record)]
+pub struct SubtitleTrackRecord {
+    pub id: i64,
+    pub language: Option<String>,
+    pub title: Option<String>,
+    pub default: bool,
+    pub forced: bool,
+    pub selected: bool,
+}
+
+/// The dialogue track to play in place of the subtitle track mpv chose, when
+/// mpv chose the signs and songs (`pstr_core::subtitles`). Asked once per file,
+/// as soon as mpv has loaded it and made its own pick.
+#[uniffi::export]
+pub fn full_subtitles_instead(tracks: Vec<SubtitleTrackRecord>) -> Option<i64> {
+    let tracks: Vec<SubtitleTrack> = tracks
+        .into_iter()
+        .map(|track| SubtitleTrack {
+            id: track.id,
+            language: track
+                .language
+                .filter(|language| !language.trim().is_empty()),
+            title: track.title.filter(|title| !title.trim().is_empty()),
+            default: track.default,
+            forced: track.forced,
+            selected: track.selected,
+        })
+        .collect();
+    pstr_core::subtitles::full_instead(&tracks)
+}
+
 /// What the app is holding on disk. Offline episodes are the viewer's, the
 /// block cache is not: only the latter may be reclaimed without asking.
 #[derive(Debug, Clone, uniffi::Record)]

crates/pstr-app/src/playback.rs

@@ -578,6 +578,15 @@ fn run(
                 if let Some(show) = target.track_prefs.as_deref() {
                     restore_tracks(&player, show);
                 }
+                // A subtitle track picked by name stays; one mpv picked by
+                // language may be the signs and songs, not the dialogue.
+                let picked = target
+                    .track_prefs
+                    .as_deref()
+                    .is_some_and(|show| show.subtitle_title.is_some());
+                if !picked {
+                    prefer_full_subtitles(&player);
+                }
                 emit_tracks(&engine, id, &player);
             }
             PlayerEvent::Duration(value) => duration = Some(*value),
@@ -735,6 +744,16 @@ fn restore_tracks(player: &Player, show: &pstr_core::catalog::TitleTrackPrefs) {
     }
 }
 
+/// Play the dialogue rather than the signs and songs mpv picked by language.
+/// Not remembered: it is the choice mpv should have made, not the viewer's.
+fn prefer_full_subtitles(player: &Player) {
+    if let Some(track) = pstr_player::full_subtitles_instead(&player.tracks())
+        && let Err(error) = player.select_track(TrackKind::Subtitle, Some(track))
+    {
+        tracing::warn!("select dialogue subtitle {track}: {error}");
+    }
+}
+
 /// Hand mpv the subtitle files paired with the video it has just loaded.
 ///
 /// One is turned on only when subtitles are on and the video has none of its

crates/pstr-core/src/lib.rs

@@ -21,6 +21,7 @@ pub mod prefs;
 pub mod profile;
 pub mod shares;
 pub mod shelves;
+pub mod subtitles;
 pub mod sync;
 
 pub use account::{Account, AccountStore};

crates/pstr-core/src/subtitles.rs

@@ -0,0 +1,202 @@
+//! Which of a file's subtitle tracks is the one to read.
+//!
+//! Anime releases often carry two subtitle tracks in one language: the
+//! dialogue, and a "Signs & Songs" track that only translates the on-screen
+//! text and the lyrics. The second is the one marked default or forced as
+//! often as not, and mpv, picking by language, plays it — an episode where
+//! nobody seems to speak. A language cannot tell the two apart; the track's
+//! name and its forced flag can.
+//!
+//! Nothing here talks to a player. Every client reads the track list out of
+//! mpv once a file is loaded and asks [`full_instead`] whether to switch.
+
+use crate::language::same_language;
+
+/// One subtitle track of the open file, as mpv lists it.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct SubtitleTrack {
+    /// mpv's id for it, what `sid` is set to.
+    pub id: i64,
+    pub language: Option<String>,
+    /// The name the muxer gave it: "Dialogue", "Signs & Songs".
+    pub title: Option<String>,
+    /// The container marks it as the default choice.
+    pub default: bool,
+    /// The container marks it as forced: on-screen text only, by convention.
+    pub forced: bool,
+    /// It is the one playing.
+    pub selected: bool,
+}
+
+/// How much of what is said a track carries, as far as its name and flags say.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Coverage {
+    /// Signs, songs, or forced: not the dialogue.
+    Partial,
+    /// Nothing says either way.
+    Unknown,
+    /// Named as the dialogue: "Dialogue", "Full Subtitles", "SDH".
+    Full,
+}
+
+/// Words in a track's name that make it the whole dialogue. They win over the
+/// partial ones: "Full (with Signs)" is still the full track.
+const FULL_WORDS: [&str; 6] = ["full", "dialogue", "dialog", "dialogues", "sdh", "cc"];
+
+/// Words in a track's name that make it something other than the dialogue.
+const PARTIAL_WORDS: [&str; 13] = [
+    "sign", "signs", "song", "songs", "s&s", "forced", "karaoke", "lyrics", "op", "ed", "oped",
+    "opening", "ending",
+];
+
+impl SubtitleTrack {
+    pub fn coverage(&self) -> Coverage {
+        let title = self.title.as_deref().unwrap_or_default().to_lowercase();
+        let words: Vec<&str> = title
+            .split(|c: char| !c.is_alphanumeric() && c != '&')
+            .filter(|word| !word.is_empty())
+            .collect();
+        let has = |list: &[&str]| words.iter().any(|word| list.contains(word));
+        if has(&FULL_WORDS) {
+            Coverage::Full
+        } else if self.forced || has(&PARTIAL_WORDS) {
+            Coverage::Partial
+        } else {
+            Coverage::Unknown
+        }
+    }
+}
+
+/// The track to play in place of the one mpv chose, if it chose the wrong one.
+///
+/// Only a track in the same language as the playing one is considered — the
+/// language is the viewer's choice, and this only corrects which of its tracks
+/// was taken. The playing track is replaced when it is partial and the file has
+/// one in its language that is not, or when nothing names it and another is
+/// named as the dialogue. Among the rest, a track named as the dialogue comes
+/// first, then the container's default, then the file's order. `None` leaves
+/// the selection as it is, which includes subtitles being off.
+pub fn full_instead(tracks: &[SubtitleTrack]) -> Option<i64> {
+    let playing = tracks.iter().find(|track| track.selected)?;
+    let current = playing.coverage();
+    if current == Coverage::Full {
+        return None;
+    }
+    let same = |track: &SubtitleTrack| match (&playing.language, &track.language) {
+        (Some(a), Some(b)) => same_language(a, b),
+        (None, None) => true,
+        _ => false,
+    };
+    tracks
+        .iter()
+        .filter(|track| track.id != playing.id && same(track))
+        .filter(|track| track.coverage() > current)
+        // `max_by_key` keeps the last of equals; reversed, the first.
+        .rev()
+        .max_by_key(|track| (track.coverage(), track.default))
+        .map(|track| track.id)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn track(id: i64, language: &str, title: &str) -> SubtitleTrack {
+        SubtitleTrack {
+            id,
+            language: Some(language.into()),
+            title: (!title.is_empty()).then(|| title.into()),
+            ..SubtitleTrack::default()
+        }
+    }
+
+    fn playing(mut track: SubtitleTrack) -> SubtitleTrack {
+        track.selected = true;
+        track
+    }
+
+    #[test]
+    fn signs_and_songs_playing_gives_way_to_the_dialogue_in_its_language() {
+        let tracks = [
+            playing(track(1, "eng", "Signs & Songs")),
+            track(2, "eng", "Dialogue"),
+        ];
+        assert_eq!(full_instead(&tracks), Some(2));
+    }
+
+    #[test]
+    fn an_unnamed_track_gives_way_to_one_named_as_the_dialogue() {
+        let tracks = [playing(track(1, "en", "")), track(2, "en", "Dialogue")];
+        assert_eq!(full_instead(&tracks), Some(2));
+    }
+
+    #[test]
+    fn a_forced_track_gives_way_to_an_unnamed_one_and_the_default_comes_first() {
+        let mut forced = playing(track(1, "eng", "English"));
+        forced.forced = true;
+        let mut default = track(3, "eng", "");
+        default.default = true;
+        let tracks = [forced, track(2, "eng", ""), default];
+        assert_eq!(full_instead(&tracks), Some(3));
+    }
+
+    #[test]
+    fn equal_candidates_resolve_to_the_first_in_the_file() {
+        let tracks = [
+            playing(track(1, "eng", "Songs")),
+            track(2, "eng", ""),
+            track(3, "eng", ""),
+        ];
+        assert_eq!(full_instead(&tracks), Some(2));
+    }
+
+    #[test]
+    fn a_track_in_another_language_is_never_switched_to() {
+        let tracks = [
+            playing(track(1, "eng", "Signs")),
+            track(2, "ger", "Dialogue"),
+        ];
+        assert_eq!(full_instead(&tracks), None);
+    }
+
+    #[test]
+    fn two_letter_and_three_letter_tags_are_one_language() {
+        let tracks = [playing(track(1, "en", "OP/ED")), track(2, "eng", "")];
+        assert_eq!(full_instead(&tracks), Some(2));
+    }
+
+    #[test]
+    fn the_dialogue_playing_stays_and_subtitles_off_stay_off() {
+        let tracks = [
+            track(1, "eng", "Signs & Songs"),
+            playing(track(2, "eng", "Dialogue")),
+        ];
+        assert_eq!(full_instead(&tracks), None);
+        let off = [
+            track(1, "eng", "Signs & Songs"),
+            track(2, "eng", "Dialogue"),
+        ];
+        assert_eq!(full_instead(&off), None);
+    }
+
+    #[test]
+    fn a_full_word_outweighs_a_partial_one_in_the_same_name() {
+        assert_eq!(
+            track(1, "eng", "Full (with Signs)").coverage(),
+            Coverage::Full
+        );
+        assert_eq!(track(1, "eng", "Signs/Songs").coverage(), Coverage::Partial);
+        assert_eq!(track(1, "eng", "English").coverage(), Coverage::Unknown);
+        // A word inside another is not that word.
+        assert_eq!(
+            track(1, "eng", "Designer cut").coverage(),
+            Coverage::Unknown
+        );
+    }
+
+    #[test]
+    fn a_partial_track_with_only_partial_company_stays() {
+        let tracks = [playing(track(1, "eng", "Signs")), track(2, "eng", "Songs")];
+        assert_eq!(full_instead(&tracks), None);
+    }
+}

crates/pstr-player/src/lib.rs

@@ -52,4 +52,4 @@ pub use player::{
 };
 pub use registry::{PROTOCOL, StreamHandle, StreamRegistry};
 pub use render::VideoRenderer;
-pub use tracks::{LANGUAGES, Track, TrackKind, language_name, pick_track};
+pub use tracks::{LANGUAGES, Track, TrackKind, full_subtitles_instead, language_name, pick_track};

crates/pstr-player/src/tracks.rs

@@ -12,6 +12,7 @@
 //! an empty string.
 
 use libmpv2::Mpv;
+use pstr_core::subtitles::{SubtitleTrack, full_instead};
 
 /// What a track carries.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -69,6 +70,9 @@ pub struct Track {
     pub selected: bool,
     /// Whether the container marks it as the default choice.
     pub default: bool,
+    /// Whether the container marks it as forced: a subtitle track of the
+    /// on-screen text alone.
+    pub forced: bool,
     /// True for a track added from outside the file — a sidecar subtitle. None
     /// of ours are, yet.
     pub external: bool,
@@ -152,6 +156,24 @@ pub fn pick_track(
     )
 }
 
+/// The dialogue track to play in place of the subtitle track mpv chose, when
+/// mpv chose signs and songs; see [`pstr_core::subtitles::full_instead`].
+pub fn full_subtitles_instead(tracks: &[Track]) -> Option<i64> {
+    let subtitles: Vec<_> = tracks
+        .iter()
+        .filter(|track| track.kind == TrackKind::Subtitle)
+        .map(|track| SubtitleTrack {
+            id: track.id,
+            language: track.language.clone(),
+            title: track.title.clone(),
+            default: track.default,
+            forced: track.forced,
+            selected: track.selected,
+        })
+        .collect();
+    full_instead(&subtitles)
+}
+
 fn read_one(mpv: &Mpv, index: i64) -> Option<Track> {
     let kind = TrackKind::from_mpv(&text(mpv, index, "type")?)?;
     let id: i64 = mpv
@@ -167,6 +189,7 @@ fn read_one(mpv: &Mpv, index: i64) -> Option<Track> {
         codec: text(mpv, index, "codec"),
         selected: flag(mpv, index, "selected"),
         default: flag(mpv, index, "default"),
+        forced: flag(mpv, index, "forced"),
         external: flag(mpv, index, "external"),
     })
 }
@@ -200,6 +223,7 @@ mod tests {
             codec: None,
             selected: false,
             default: false,
+            forced: false,
             external: false,
         }
     }