expo-video-subtitle 0.7.2 → 0.7.4

package/CHANGELOG.md

@@ -7,6 +7,50 @@ 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.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.
+
+### Changed
+
+- **The sign store falls back to the only script it holds when the track id does not match.** The
+  parser reads `Format.id` from the `Format` its factory was handed; the overlay reads it from the
+  selected text track. Those should be the same value, but if they ever are not, the failure is
+  silent and total — signs parse correctly and never appear, which is precisely how the previous two
+  delivery attempts failed. With one track loaded there is nothing to be ambiguous about. With
+  several it still declines, because a wrong guess would draw one language's typesetting over
+  another's.
+
+- **The overlay logs what it resolved.** Every way this subsystem has failed so far has been quiet:
+  a dropped span, a rejected timestamp, an id that did not match. One line under the `AssSignOverlay`
+  tag now says which text track was selected and how many signs were found for it, so the next
+  failure is one `logcat` away instead of a bisect.
+
 ## 0.7.2
 
 ### Fixed

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
@@ -18,6 +19,7 @@ import androidx.annotation.OptIn
 import androidx.media3.common.C
 import androidx.media3.common.Player
 import androidx.media3.common.Tracks
+import androidx.media3.common.util.Log
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.ui.PlayerView
 import androidx.media3.ui.SubtitleView
@@ -101,8 +103,13 @@ internal class AssSignOverlay(context: Context) : View(context), Player.Listener
   }
 
   private fun resolveScript() {
-    val next = AssSignStore.get(selectedTextTrackId())
+    val trackId = selectedTextTrackId()
+    val next = AssSignStore.get(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
+    // have named the stage that broke.
+    Log.i(TAG, "ASS signs for $trackId: ${next?.signs?.size ?: "none"}")
     script = next
     layouts = HashMap()
     setActive(emptyList())
@@ -138,20 +145,48 @@ 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))
+
+    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
+      lastLookupMs = now
+      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
@@ -318,6 +353,10 @@ 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. */
@@ -339,8 +378,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

@@ -47,9 +47,21 @@ internal object AssSignStore {
     scripts[trackId] = script
   }
 
-  /** Called from the main thread, once per track change. */
+  /**
+   * Called from the main thread, once per track change.
+   *
+   * 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.
+   */
   @Synchronized
-  fun get(trackId: String?): AssScript? = trackId?.let { scripts[it] }
+  fun get(trackId: String?): AssScript? {
+    scripts[trackId]?.let { return it }
+    return scripts.values.singleOrNull()
+  }
 
   @Synchronized
   fun clear() {

package/package.json

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