expo-video-subtitle 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -7,6 +7,34 @@ Changes inherited from the upstream base version are not repeated here — see t
 [upstream changelog](https://github.com/expo/expo/blob/main/packages/expo-video/CHANGELOG.md)
 for the history of everything that isn't subtitle related.
 
+## 0.7.5
+
+### Fixed
+
+- **One episode's signs drew over the next one.** Opening episode 4 after episode 3 kept episode 3's
+  typesetting on screen for the whole runtime.
+
+  The cause was insurance added in 0.7.3 that turned into the bug it was insuring against.
+  `AssSignStore.get` answered a missed track id with "the only script on hand", to protect against
+  the parser and the overlay disagreeing about `Format.id`. They do not disagree — a device run
+  confirmed both name the same track — and the fallback fired in a case that was never considered:
+  a new episode misses on its own id for the first twelve seconds, while its 2.7 MB file is still
+  parsing, and the only script on hand is the previous episode's. Once resolved, the overlay stops
+  looking for a better one, so it never corrected itself.
+
+  A miss is now a miss. It means "not parsed yet", which the overlay already polls through.
+
+- **A track change is noticed without waiting to be told.** The overlay re-resolved only when it had
+  no script at all, so it leaned on `onTracksChanged` to catch a switch. It now compares the track
+  its script came from against the one currently selected, four times a second, and re-resolves when
+  they differ.
+
+### Changed
+
+- The store keeps two tracks rather than four. That covers switching language within an episode and
+  moving to the next one, and each entry holds every sign in an episode — 12,616 in the file this
+  was built against.
+
 ## 0.7.4
 
 Signs render. This is the release where the feature added in 0.7.0 actually reaches the screen.

package/android/src/main/java/expo/modules/video/utils/AssSignOverlay.kt

@@ -55,6 +55,8 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
 
   private var player: Player? = null
   private var script: AssScript? = null
+  /** The track [script] belongs to, so a change of track is noticed even mid-poll. */
+  private var scriptTrackId: String? = null
 
   private var active: List<AssSign> = emptyList()
   private var prepared: List<PreparedSign> = emptyList()
@@ -93,6 +95,7 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
     player?.removeListener(this)
     player = null
     script = null
+    scriptTrackId = null
     layouts = HashMap()
     setActive(emptyList())
   }
@@ -105,6 +108,7 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
   private fun resolveScript() {
     val trackId = selectedTextTrackId()
     val next = AssSignStore.get(trackId)
+    scriptTrackId = trackId
     if (next === script) return
     // The one line worth keeping. Every failure of this subsystem has been silent — a span dropped
     // by Parcel, a timestamp rejected, a loop that never started — and each time this line would
@@ -169,17 +173,23 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
   private fun tick() {
     val player = this.player ?: return
 
-    if (script == null) {
-      // Poll rather than wait to be told. The parser finishes on another thread whenever the file
-      // finishes downloading, and nothing in Media3 announces "a subtitle has been parsed" — the
-      // cue stream would have, which is exactly what this design gave up. Four times a second is
-      // far below the cost of the map lookup it does.
-      val now = SystemClock.uptimeMillis()
-      if (now - lastLookupMs < LOOKUP_INTERVAL_MS) return
+    // Polled rather than waited for, on two counts.
+    //
+    // A script arrives late: the parser runs on another thread whenever the file finishes
+    // downloading — about twelve seconds on a 2.7 MB script — and nothing in Media3 announces "a
+    // subtitle has been parsed". The cue stream would have, which is exactly what this design gave
+    // up.
+    //
+    // And the track changes underneath: moving to the next episode swaps the selected text track,
+    // and `onTracksChanged` is not something to stake the whole feature on. Comparing the track this
+    // script came from against the one selected now catches it either way — without that, episode
+    // three's signs kept drawing over episode four.
+    val now = SystemClock.uptimeMillis()
+    if (now - lastLookupMs >= LOOKUP_INTERVAL_MS) {
       lastLookupMs = now
-      resolveScript()
-      if (script == null) return
+      if (script == null || selectedTextTrackId() != scriptTrackId) resolveScript()
     }
+    if (script == null) return
 
     val script = this.script ?: return
     val positionUs = player.contentPosition * 1000L

package/android/src/main/java/expo/modules/video/utils/AssSignStore.kt

@@ -30,11 +30,11 @@ package expo.modules.video.utils
 internal object AssSignStore {
 
   /**
-   * Enough for the track being watched plus a few the viewer switched away from. Each entry holds
-   * every sign in an episode — 12,616 in the file this was built against — so this is not a cache to
-   * let grow.
+   * The track being watched plus the one before it, which covers switching language mid-episode and
+   * moving to the next episode. Each entry holds every sign in an episode — 12,616 in the file this
+   * was built against — so this is not a cache to let grow.
    */
-  private const val MAX_TRACKS = 4
+  private const val MAX_TRACKS = 2
 
   private val scripts = object : LinkedHashMap<String, AssScript>(MAX_TRACKS, 0.75f, true) {
     override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, AssScript>): Boolean =
@@ -48,20 +48,20 @@ internal object AssSignStore {
   }
 
   /**
-   * Called from the main thread, once per track change.
+   * Strictly by id. A miss is a miss.
    *
-   * Falls back to the only script on hand when the id does not match. The two ends read `Format.id`
-   * from different places — the parser from the `Format` its factory was handed, the overlay from
-   * the selected track — and if those ever disagree the failure is silent and total: signs parse
-   * perfectly and never appear, which is exactly how the previous delivery route failed. With one
-   * track loaded there is no ambiguity to protect against, so the safe answer is the obvious one.
-   * With several, a wrong guess would draw one language's typesetting over another's, so it declines.
+   * This used to fall back to the only script on hand, as insurance against the two ends reading
+   * `Format.id` from different places and disagreeing. They do not disagree — the device confirmed
+   * the parser and the overlay name the same track — and the insurance turned out to be a bug of its
+   * own: opening a second episode misses on the new id, and "the only script on hand" is the
+   * *previous* episode's. Its signs then draw over the new one for its whole runtime, because a
+   * resolved script stops the overlay from looking again.
+   *
+   * A miss here is not a failure. It means the file has not finished parsing yet, which on a 2.7 MB
+   * script takes about twelve seconds, and the overlay polls until it has.
    */
   @Synchronized
-  fun get(trackId: String?): AssScript? {
-    scripts[trackId]?.let { return it }
-    return scripts.values.singleOrNull()
-  }
+  fun get(trackId: String?): AssScript? = trackId?.let { scripts[it] }
 
   @Synchronized
   fun clear() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-video-subtitle",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "description": "A cross-platform, performant video component for React Native and Expo with external subtitle sideloading and custom subtitle styling.",
   "keywords": [
     "expo",