expo-video-subtitle 0.7.4 → 0.7.6

package/CHANGELOG.md

@@ -7,6 +7,61 @@ 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.6
+
+### Fixed
+
+- **Signs stopped appearing at all.** The id lookup between the parser and the overlay had never
+  matched. Media3 prefixes a merged track's id with the index of the source it came from, so the
+  parser is handed `expo-subtitle:id:https://…` while the overlay reads
+  `2:expo-subtitle:id:https://…` off the selected track. Every lookup missed, and the
+  "use the only script on hand" fallback quietly covered for it — which is why removing that
+  fallback in 0.7.5 took the whole feature with it, and why the fallback's own bug (one episode's
+  signs drawing over the next) had been the only visible symptom until then.
+
+  Both ends now normalize the id through the same function before touching the map. Five tests pin
+  it, using the exact strings a device produced, and were checked by removing the normalization and
+  watching them fail.
+
+- **A track with no typesetting no longer logs once a second forever.** The parser files its result
+  even when there are no signs in it. Absence in the store used to mean two different things —
+  "still parsing" and "nothing to draw" — and the overlay kept asking for the second one.
+
+### Changed
+
+- A missed lookup is now logged, throttled to once a second, naming both the id being asked for and
+  the ids on hand. Its absence is what let this bug hide behind a fallback for three releases: the
+  overlay asked, got nothing, and said nothing, so a wrong key looked exactly like a file that had
+  not finished parsing.
+
+## 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,7 +108,19 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
   private fun resolveScript() {
     val trackId = selectedTextTrackId()
     val next = AssSignStore.get(trackId)
-    if (next === script) return
+    scriptTrackId = trackId
+    if (next === script) {
+      // Reported, not swallowed. A lookup that quietly finds nothing is how this subsystem has
+      // failed three times running: the overlay asks, gets nothing, and says nothing, so the log
+      // looks identical whether the file is still parsing or the key is simply wrong. Throttled to
+      // once a second because the poll runs four times that.
+      val now = SystemClock.uptimeMillis()
+      if (now - lastMissLogMs >= MISS_LOG_INTERVAL_MS) {
+        lastMissLogMs = now
+        Log.w(TAG, "no ASS signs for track $trackId; parsed so far: ${AssSignStore.keys()}")
+      }
+      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
     // have named the stage that broke.
@@ -165,21 +180,28 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
 
 
   private var lastLookupMs = 0L
+  private var lastMissLogMs = 0L
 
   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
@@ -357,6 +379,9 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
 
     /** How often to ask the store for a script that has not arrived yet. */
     private const val LOOKUP_INTERVAL_MS = 250L
+
+    /** How often to say so when the answer is still nothing. */
+    private const val MISS_LOG_INTERVAL_MS = 1000L
     private const val OPAQUE = 0xFF000000.toInt()
 
     /** Removes the overlay from [playerView], dropping its listener registration with it. */

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

@@ -30,38 +30,59 @@ 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 =
       size > MAX_TRACKS
   }
 
+  /**
+   * A merged track's id carries the index of the source it came from: Media3 hands the overlay
+   * `2:expo-subtitle:id:https://…` for the track the parser was given as `expo-subtitle:id:https://…`.
+   * Both ends key on the same string only if that prefix is taken off first.
+   *
+   * Measured on a device, and it is what made every id lookup miss while a fallback quietly covered
+   * for it. Stripped repeatedly, since sources can nest, and safe for these ids because
+   * `SubtitleSource` always begins them with `expo-subtitle:`, never a digit.
+   */
+  private val MERGED_SOURCE_PREFIX = Regex("""^\d+:""")
+
+  fun normalizeTrackId(trackId: String): String {
+    var id = trackId
+    while (MERGED_SOURCE_PREFIX.containsMatchIn(id)) id = id.replaceFirst(MERGED_SOURCE_PREFIX, "")
+    return id
+  }
+
   /** Called from the extractor's loading thread. */
   @Synchronized
   fun put(trackId: String, script: AssScript) {
-    scripts[trackId] = script
+    scripts[normalizeTrackId(trackId)] = script
   }
 
   /**
-   * Called from the main thread, once per track change.
+   * Strictly by id. A miss is a miss.
+   *
+   * 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.
    *
-   * 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.
+   * 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[normalizeTrackId(it)] }
+
+  /** The keys on hand, for telling a "not parsed yet" miss from a "wrong key" miss. */
+  @Synchronized
+  fun keys(): List<String> = scripts.keys.toList()
 
   @Synchronized
   fun clear() {

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

@@ -342,10 +342,13 @@ class StackingSsaParser(
       if (trackId == null) return@runCatching Split(data, offset, length)
 
       val script = AssSignParser.parse(String(data, offset, length, Charsets.UTF_8))
+      // Filed even with no signs in it. The overlay cannot tell "still parsing" from "nothing to
+      // draw" by absence alone, and would go on asking — and logging — for the whole episode.
+      AssSignStore.put(trackId, script)
+
       if (script.signs.isEmpty()) {
         Split(data, offset, length)
       } else {
-        AssSignStore.put(trackId, script)
         val dialogue = script.dialogueOnly.toByteArray(Charsets.UTF_8)
         Split(dialogue, 0, dialogue.size)
       }

package/package.json

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