expo-video-subtitle 0.7.3 → 0.7.5

package/CHANGELOG.md

@@ -7,6 +7,59 @@ 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.
+
+### Fixed
+
+- **The overlay gave up looking for its signs before they existed.** The subtitle is fetched and
+  parsed on the extractor's loading thread; on a 2.7 MB script that finished **12.4 seconds** after
+  the view had bound to the player. The overlay asked the store once at bind time, got nothing, and
+  never asked again — because the only thing that would have asked again was the frame loop, and the
+  loop was gated on already having a script. Nothing ever broke that circle.
+
+  The loop now runs whenever there is a player, and polls the store four times a second until a
+  script arrives.
+
+- **The loop declined to start at the moment it was first asked.** `attachTo` runs from
+  `configureSubtitleView`, which fires while the view is still being assembled: `player=true`,
+  `attached=false`. `onAttachedToWindow` is what starts it, and it now does.
+
+### Known behaviour
+
+- Signs appear a few seconds into playback on a large script, after the file has downloaded and
+  parsed. Dialogue is unaffected — it comes from the same file but is rendered by Media3 as it
+  arrives.
+
 ## 0.7.3
 
 Hardening only. Nothing here changes what 0.7.2 draws when 0.7.2 works.

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

@@ -8,6 +8,7 @@ import android.graphics.Color
 import android.graphics.Matrix
 import android.graphics.Paint
 import android.graphics.Typeface
+import android.os.SystemClock
 import android.text.Layout
 import android.text.StaticLayout
 import android.text.TextPaint
@@ -54,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()
@@ -92,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())
   }
@@ -104,10 +108,12 @@ 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
-    // Logged because every way this has failed so far has been silent. If signs go missing again,
-    // this line says whether the parser filed them and whether the overlay found them.
-    Log.d(TAG, "text track $trackId -> ${next?.signs?.size ?: "no"} sign(s)")
+    // 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.
+    Log.i(TAG, "ASS signs for $trackId: ${next?.signs?.size ?: "none"}")
     script = next
     layouts = HashMap()
     setActive(emptyList())
@@ -143,20 +149,54 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
     frameScheduled = false
   }
 
+  /**
+   * The loop runs whenever there is a player, script or not.
+   *
+   * Gating it on having a script deadlocked the whole feature. The subtitle is fetched and parsed on
+   * the extractor's loading thread and lands seconds after the view has bound — measured at 12.4s on
+   * a 2.7 MB script, against a bind at 0.04s. The overlay looked in the store once, found it empty,
+   * and then never looked again, because the only thing that would have looked again was the loop it
+   * had just declined to start.
+   *
+   * Paused playback ticks too: a seek while paused has to move the signs with it.
+   */
   private fun schedule() {
-    // No script means nothing to draw and no reason to hold a frame callback open. Paused playback
-    // still ticks, because a seek while paused has to move the signs with it.
-    if (frameScheduled || script == null || !isAttachedToWindow) return
+    // Not logged: this reposts on every frame by design, and a line here would be sixty a second.
+    if (frameScheduled || player == null || !isAttachedToWindow) return
     frameScheduled = true
     Choreographer.getInstance().postFrameCallback(onFrame)
   }
 
+
+  private var lastLookupMs = 0L
+
   private fun tick() {
-    val script = this.script ?: return
     val player = this.player ?: return
-    setActive(script.signsAt(player.contentPosition * 1000L))
+
+    // 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
+      if (script == null || selectedTextTrackId() != scriptTrackId) resolveScript()
+    }
+    if (script == null) return
+
+    val script = this.script ?: return
+    val positionUs = player.contentPosition * 1000L
+    setActive(script.signsAt(positionUs))
   }
 
+
   private fun setActive(next: List<AssSign>) {
     if (next.size == active.size && next.indices.all { next[it] === active[it] }) return
     active = next
@@ -324,6 +364,9 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
 
   companion object {
     private const val TAG = "AssSignOverlay"
+
+    /** How often to ask the store for a script that has not arrived yet. */
+    private const val LOOKUP_INTERVAL_MS = 250L
     private const val OPAQUE = 0xFF000000.toInt()
 
     /** Removes the overlay from [playerView], dropping its listener registration with it. */
@@ -345,8 +388,10 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
      * produce, but `PlayerView` allows.
      */
     fun install(playerView: PlayerView): AssSignOverlay? {
-      val subtitleView: SubtitleView = playerView.subtitleView ?: return null
-      val parent = subtitleView.parent as? ViewGroup ?: return null
+      val subtitleView: SubtitleView = playerView.subtitleView
+?: return null
+      val parent = subtitleView.parent as? ViewGroup
+?: return null
 
       for (index in 0 until parent.childCount) {
         (parent.getChildAt(index) as? AssSignOverlay)?.let { return it }

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.3",
+  "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",