expo-video-subtitle 0.6.0 → 0.7.1

package/CHANGELOG.md

@@ -7,6 +7,76 @@ 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.1
+
+### Fixed
+
+- **Playing an `.ass` track crashed the player (Android).** `Regex(""""\\{([^}]*)}""")` in the sign
+  parser left the closing brace unescaped. `java.util.regex` accepts that; Android compiles regular
+  expressions with **ICU**, which does not, so the pattern threw `PatternSyntaxException` out of a
+  static initialiser on the extractor's loading thread and took playback down with it —
+  `ExceptionInInitializerError` on the first ASS subtitle the app opened.
+
+  The whole class of bug is invisible to this module's JVM tests, because the offending pattern
+  compiles there. `RegexPortabilityTest` now reads the sources instead and fails on any regex
+  literal with a brace that is neither escaped nor inside a character class.
+
+- **A subtitle this package cannot read no longer stops the video.** `StackingSsaParser.split` runs
+  on the extractor's loading thread, where a thrown exception is not a failed subtitle — it is a
+  dead player. It is now wrapped end to end, and a track that fails falls back to Media3's own ASS
+  handling, which draws the captions flat. Subtitle files are untrusted scraper output; plain
+  captions are the honest failure, a black screen is not.
+
+- **A multi-line sign follows its own alignment.** Every block was laid out centred, so the second
+  line of a left- or right-anchored placard pulled to the middle.
+
+## 0.7.0
+
+### Added
+
+- **ASS signs are drawn with the transforms the script asks for (Android).** A typeset sign is
+  placed on the artwork, and the artwork is usually not square to the screen: in one episode of
+  Jujutsu Kaisen S3, 3,723 events carry `\frz`, 1,304 of them past 5° and 104 past 45°, because the
+  placards they sit on are drawn at an angle. Rendered flat, the translation reads as pasted over
+  the picture instead of lying on it.
+
+  Media3 cannot do this and has no room to. `SubtitlePainter` contains no call to `rotate`, `skew`,
+  `Matrix` or `Camera`; `Cue` carries no rotation field, only `shearDegrees`, which the painter
+  ignores; and `SsaParser` discards every override block except `\pos`, `\move` and `\an`.
+
+  So signs leave Media3's hands entirely. `AssSignParser` splits a script in two — typeset events
+  to us, dialogue to the delegate, with the sign lines cut out of the copy the delegate parses, so
+  double-drawing is structurally impossible rather than merely avoided. Each sign rides the cue
+  stream as a zero-width placeholder carrying an `AssSignSpan`, which buys Media3's timing for free,
+  and `AssSignOverlay` draws it on a canvas in front of the captions.
+
+  Read and honoured: `\pos`, `\move` (at its destination), `\org`, `\an` and the legacy `\a`,
+  `\frz`, `\frx`, `\fry`, `\fscx`, `\fscy`, `\fs`, `\c` / `\1c`, `\alpha` / `\1a`, `\b`,
+  `\i`, `\u`, style `Alignment`, `Fontsize`, `PrimaryColour`, `OutlineColour`, `Outline`,
+  `ScaleX/Y`, `Angle` and the margins, plus `PlayResX` / `PlayResY` and VSFilter's 4:3 rule when one
+  is missing.
+
+  The overlay sits in the player's content frame, which is sized to the video rather than the view,
+  so positions survive letterboxing.
+
+### Known limitations
+
+- `\t` animation, `\fad`, `\clip`, `\blur`, `\be`, `\fax` shear, vector drawings and karaoke are
+  still dropped. Reproducing those means libass, not a larger subset of it.
+- Fonts fall back to the system face: a script naming `Bogart Semibold` gets the default at the
+  right size and weight, not that typeface.
+- `\frx` and `\fry` are applied with an unverified sign convention. They are almost always tiny —
+  3,363 of 5,126 `\frx` values and 2,715 of 3,579 `\fry` values in that episode are under 3° — so a
+  wrong sign is subtle rather than visible. `\frz` is what carries the effect and is verified
+  against the source line it came from.
+- iOS still draws signs flat. AVFoundation renders WebVTT itself and has no rotation to give.
+
+### Changed
+
+- The module now has JVM unit tests (`./gradlew :expo-video-subtitle:testDebugUnitTest`). The sign
+  parser is pure Kotlin with no Android imports precisely so it can be tested this way: its tag
+  scanner and colour handling fail by drawing a sign in the wrong place, which nothing else catches.
+
 ## 0.6.0
 
 ### Fixed

package/FORK.md

@@ -29,6 +29,9 @@ Measured against the published `expo-video@56.1.4` tarball. `+`/`-` are added/re
 | `android/…/records/SubtitleStyle.kt` | 152 | Record → `CaptionStyleCompat`; hex colour parsing; font-family resolution (`res/font` → `ReactFontManager`); the `applyEmbeddedStyles` flag, which `SubtitleUtils` reads directly rather than `toCaptionStyle` and which defaults to `true` since 0.5.0. |
 | `android/…/utils/StackingSubtitleParser.kt` | 342 | `SubtitleParser` that segments the cue timeline and merges simultaneous **unpositioned** cues into one stacked block, plus the `SubtitleParser.Factory` that routes SubRip and ASS/SSA to it and wraps every parser in `FilteringSubtitleParser`. ASS gets there through `SsaCueNormalizer` as the `prepare` step — without it `SsaParser` sets both `line` and `position` on every cue and they would all take the passthrough branch. Assigns each cue a vertical slot it keeps for its whole time on screen — a finished cue's line is held blank (`\u200B`) so the cues above it do not drop. Merges through a `SpannableStringBuilder` so cue spans survive. |
 | `android/…/utils/SsaCueNormalizer.kt` | 93 | Clears the `line`/`position` Media3's `SsaParser` fills in on cues the ASS author never placed, so `bottomOffset` and cue stacking work on `.ass` the way they already do on `.srt`. The test is exact rather than heuristic: those values are a pure function of the cue's anchors, so matching both defaults for the bottom-centre anchors *is* "no positioning tag". Also drops events on a style the author made invisible (`Fontsize 0`, or a primary colour whose inverted alpha byte is `FF`) — that is where typesetters park working notes, and nothing downstream can carry "invisible". |
+| `android/…/utils/AssSignParser.kt` | 505 | Splits an ASS script into the typeset events this package draws and a copy of the script with those lines removed for Media3's parser. One pass, no matching step, so an event is in exactly one of the two outputs and cannot be drawn twice. Pure Kotlin with no Android imports, which is what makes it unit-testable on the JVM. Reads `\pos`, `\move`, `\org`, `\an`, `\frz`, `\frx`, `\fry`, `\fscx/y`, `\fs`, `\c`, `\alpha`, `\b`, `\i`, `\u` and the style columns behind them. The tag scanner takes the longest name first — `\c` must not swallow `\clip`, `\b` must not swallow `\bord`, `\blur` or `\be` — and reads a leading digit as part of the name for `\1c` and `\4a`. |
+| `android/…/utils/AssSignOverlay.kt` | 235 | Draws those signs on a canvas in front of the captions, with `Matrix` for rotation and scale and `Camera` for the two 3-D axes. **Media3 cannot do this**: `SubtitlePainter` has no rotate, skew, Matrix or Camera call, and `Cue` has no rotation field. Sits in the same parent as `SubtitleView` — the content frame, sized to the video, which is why `\pos` survives letterboxing. Lays text out on change rather than per frame, because frame-by-frame typesetting changes the on-screen set every 40 ms. |
+| `android/…/utils/AssSignSpan.kt` | 24 | Carries one parsed sign through Media3's cue stream to the overlay, on a zero-width placeholder so `SubtitleView` draws nothing. Riding the cue stream is what buys the timing for free. |
 | `android/…/utils/RoundedSubtitleBackground.kt` | 352 | Draws `subtitleStyle.backgroundRadius` as rounded boxes, which Media3 cannot do at all: it paints `backgroundColor` as a framework `BackgroundColorSpan` and `windowColor` with `canvas.drawRect`, neither takes a radius, and `SubtitlePainter`/`CanvasSubtitleOutput` are package-private final while `SubtitleView` is final. A second `SubtitleView` is inserted behind `PlayerView`'s own, fed from `Player.Listener.onCues`, drawing a `LineBackgroundSpan` per line. **Its `EDGE_TYPE_NONE` is load-bearing** — `SubtitlePainter` copies the cue text for an edge pass and draws both layouts when the edge type is outline/raised/depressed, which would paint the box twice and darken a semi-transparent colour. State hangs off the view's `tag`, never a map in the companion object; see the `find` KDoc for why even a `WeakHashMap` leaks here. |
 | `FORK.md`, `LICENSE` | — | This guide; MIT licence (upstream copyright preserved). |
 | `eslint.config.js` | 4 | Verbatim copy of `expo-module-scripts/templates/eslint.config.js`. **Recreate it if a sync drops it** — `expo-module configure` treats it as an *optional* template and only syncs it when it already exists, so without this file `npm run lint` dies with "ESLint couldn't find an eslint.config.js". |

package/android/build.gradle

@@ -26,6 +26,11 @@ dependencies {
   implementation "androidx.media3:media3-ui:${androidxMedia3Version}"
   implementation "androidx.media3:media3-datasource-okhttp:${androidxMedia3Version}"
 
+  // The ASS sign parser is pure Kotlin with no Android imports, which is what makes it worth
+  // testing on the JVM: its tag scanner and colour handling are the parts that fail silently on a
+  // device, by drawing a sign in the wrong place rather than by crashing.
+  testImplementation 'junit:junit:4.13.2'
+
   def fragment_version = "1.8.9"
   implementation "androidx.fragment:fragment:$fragment_version"
   implementation "androidx.fragment:fragment-ktx:$fragment_version"

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

@@ -0,0 +1,276 @@
+package expo.modules.video.utils
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Camera
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.text.Layout
+import android.text.StaticLayout
+import android.text.TextPaint
+import android.view.View
+import android.view.ViewGroup
+import androidx.annotation.OptIn
+import androidx.media3.common.Player
+import androidx.media3.common.text.Cue
+import androidx.media3.common.text.CueGroup
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.PlayerView
+import androidx.media3.ui.SubtitleView
+
+/**
+ * Draws ASS typesetting — signs, placards, on-screen labels — with the transforms the script asks
+ * for.
+ *
+ * `SubtitleView` cannot: `SubtitlePainter` has no rotation, and `Cue` has no field to carry one.
+ * So [AssSignParser] takes those events out of Media3's cue stream, wraps each in an [AssSignSpan],
+ * and this view draws them itself.
+ *
+ * ### Where it sits
+ *
+ * As a sibling of `PlayerView`'s own `SubtitleView`, in front of it. That parent is the content
+ * frame, which is sized to the *video*, not to the player — which is the whole reason positions
+ * survive letterboxing. `\pos` is in `PlayResX`/`PlayResY` space and maps onto this view's bounds
+ * directly. [RoundedSubtitleBackground] takes the same route for the same reason.
+ *
+ * ### Why a canvas and not child views
+ *
+ * A `TextView` per sign would work — Android view transforms map onto ASS almost one for one — but
+ * a heavily typeset episode puts dozens of signs on screen across a scene and each would cost a
+ * measure and layout pass. Drawing straight to the canvas costs one `StaticLayout` per sign per
+ * frame it changes, and it is the only way to stroke the outline the way ASS means it: the border
+ * drawn *behind* the fill, not as a shadow.
+ */
+@SuppressLint("ViewConstructor")
+@OptIn(UnstableApi::class)
+internal class AssSignOverlay(context: Context) : View(context), Player.Listener {
+
+  private val camera = Camera()
+  private val matrix = Matrix()
+
+  private var signs: List<AssSign> = emptyList()
+  private var prepared: List<PreparedSign> = emptyList()
+  private var player: Player? = null
+
+  init {
+    setWillNotDraw(false)
+  }
+
+  override fun onCues(cueGroup: CueGroup) {
+    setSigns(cueGroup.cues)
+  }
+
+  private fun setSigns(cues: List<Cue>) {
+    val next = cues.mapNotNull(::signOf)
+    // Reference equality on the list contents is enough: the parser produces one AssSign per event
+    // and hands out the same instance for every segment the event spans.
+    if (next.size == signs.size && next.indices.all { next[it] === signs[it] }) return
+    signs = next
+    rebuild()
+  }
+
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+    // Every measurement below is in view pixels, so all of it is stale after a resize — which
+    // happens on every rotation and on entering full screen.
+    rebuild()
+  }
+
+  /**
+   * Lays the signs out once per change rather than once per frame.
+   *
+   * Frame-by-frame typesetting changes the on-screen set every 40 ms, and `onDraw` can run more
+   * often than that for reasons of the view system's own. Text layout is the expensive half of
+   * drawing, and none of it depends on anything that varies between frames.
+   */
+  private fun rebuild() {
+    prepared = if (width == 0 || height == 0) emptyList() else signs.mapNotNull(::prepare)
+    invalidate()
+  }
+
+  fun attachTo(player: Player?) {
+    if (this.player === player) return
+    this.player?.removeListener(this)
+    this.player = player
+    player?.addListener(this)
+    // A listener only hears about the *next* cue change, so seed from what is on screen already.
+    setSigns(player?.currentCues?.cues ?: emptyList())
+  }
+
+  fun detach() {
+    player?.removeListener(this)
+    player = null
+    signs = emptyList()
+    rebuild()
+  }
+
+  override fun onDraw(canvas: Canvas) {
+    for (sign in prepared) {
+      draw(canvas, sign)
+    }
+  }
+
+  private fun draw(canvas: Canvas, sign: PreparedSign) {
+    canvas.save()
+    canvas.concat(sign.matrix)
+    canvas.translate(sign.left, sign.top)
+    sign.stroke?.draw(canvas)
+    sign.fill.draw(canvas)
+    canvas.restore()
+  }
+
+  /** Everything about one sign that does not change between frames. */
+  private class PreparedSign(
+    val matrix: Matrix,
+    val left: Float,
+    val top: Float,
+    val fill: StaticLayout,
+    val stroke: StaticLayout?,
+  )
+
+  private fun prepare(sign: AssSign): PreparedSign? {
+    // Script space to view space. Both axes are scaled independently so a script authored at a
+    // different aspect ratio than the video still lands where it was drawn.
+    val scaleToViewX = width / sign.playResX
+    val scaleToViewY = height / sign.playResY
+
+    val alpha = (sign.alpha * 255f).toInt().coerceIn(0, 255)
+    if (alpha == 0) return null
+
+    // A fresh paint per sign: StaticLayout keeps the reference it was built with, so a shared
+    // mutable one would repaint every sign already laid out in this pass.
+    val fillPaint = TextPaint(Paint.ANTI_ALIAS_FLAG)
+    fillPaint.applySign(sign, scaleToViewY)
+    fillPaint.color = Color.argb(alpha, Color.red(sign.colour or ALPHA_MASK), Color.green(sign.colour or ALPHA_MASK), Color.blue(sign.colour or ALPHA_MASK))
+
+    // Wrapping is the script's job, not ours: a sign is placed by hand and its line breaks are
+    // written into the text as \N. A width of "as wide as it wants" reproduces that.
+    val textWidth = Layout.getDesiredWidth(sign.text, fillPaint).toInt() + 1
+    // A multi-line sign wraps its lines the way its own alignment says, not always centred: a
+    // left-anchored placard reads wrong with its second line pulled to the middle.
+    val blockAlignment = when ((sign.alignment - 1) % 3) {
+      0 -> Layout.Alignment.ALIGN_NORMAL
+      2 -> Layout.Alignment.ALIGN_OPPOSITE
+      else -> Layout.Alignment.ALIGN_CENTER
+    }
+    val layout = StaticLayout.Builder
+      .obtain(sign.text, 0, sign.text.length, fillPaint, textWidth)
+      .setAlignment(blockAlignment)
+      .setIncludePad(false)
+      .build()
+
+    val anchorX = sign.x * scaleToViewX
+    val anchorY = sign.y * scaleToViewY
+    // \pos names the point the cue's *alignment corner* sits on, so the box is offset from it.
+    val left = anchorX - when ((sign.alignment - 1) % 3) {
+      0 -> 0f
+      2 -> layout.width.toFloat()
+      else -> layout.width / 2f
+    }
+    val top = anchorY - when ((sign.alignment - 1) / 3) {
+      0 -> layout.height.toFloat()
+      2 -> 0f
+      else -> layout.height / 2f
+    }
+
+    // \org moves the centre of rotation away from the text, which is how a sign stays glued to a
+    // placard that is itself pivoting off-screen. Without it every rotation would spin about the
+    // text's own middle and drift off the artwork.
+    val pivotX = sign.pivotX * scaleToViewX
+    val pivotY = sign.pivotY * scaleToViewY
+
+    matrix.reset()
+    if (sign.rotationX != 0f || sign.rotationY != 0f) {
+      camera.save()
+      camera.rotateX(sign.rotationX)
+      camera.rotateY(sign.rotationY)
+      camera.getMatrix(matrix)
+      camera.restore()
+      // Camera transforms about the origin, so the pivot has to be walked to it and back.
+      matrix.preTranslate(-pivotX, -pivotY)
+      matrix.postTranslate(pivotX, pivotY)
+    }
+    matrix.postScale(sign.scaleX, sign.scaleY, pivotX, pivotY)
+    matrix.postRotate(sign.rotationZ, pivotX, pivotY)
+
+    val stroke = if (sign.outlineWidth <= 0f) null else {
+      val strokePaint = TextPaint(Paint.ANTI_ALIAS_FLAG)
+      strokePaint.style = Paint.Style.STROKE
+      strokePaint.applySign(sign, scaleToViewY)
+      strokePaint.strokeWidth = sign.outlineWidth * scaleToViewY * 2f
+      strokePaint.color = Color.argb(alpha, Color.red(sign.outlineColour or ALPHA_MASK), Color.green(sign.outlineColour or ALPHA_MASK), Color.blue(sign.outlineColour or ALPHA_MASK))
+      // The stroke is centred on the glyph edge, so half of it lands inside the letter. Drawing the
+      // fill afterwards covers that half and leaves the outline the width the script asked for.
+      StaticLayout.Builder
+        .obtain(sign.text, 0, sign.text.length, strokePaint, textWidth)
+        .setAlignment(blockAlignment)
+        .setIncludePad(false)
+        .build()
+    }
+
+    return PreparedSign(Matrix(matrix), left, top, layout, stroke)
+  }
+
+  private fun TextPaint.applySign(sign: AssSign, scaleToViewY: Float) {
+    textSize = sign.fontSize * scaleToViewY
+    typeface = Typeface.create(
+      Typeface.DEFAULT,
+      when {
+        sign.bold && sign.italic -> Typeface.BOLD_ITALIC
+        sign.bold -> Typeface.BOLD
+        sign.italic -> Typeface.ITALIC
+        else -> Typeface.NORMAL
+      },
+    )
+    isUnderlineText = sign.underline
+  }
+
+  companion object {
+    /** ASS colours are stored without an alpha byte; opacity travels separately. */
+    private const val ALPHA_MASK = 0xFF000000.toInt()
+
+    private fun signOf(cue: Cue): AssSign? {
+      val text = cue.text as? android.text.Spanned ?: return null
+      return text.getSpans(0, text.length, AssSignSpan::class.java).firstOrNull()?.sign
+    }
+
+    /**
+     * Inserts the overlay in front of `PlayerView`'s subtitle view, or returns the one already
+     * there.
+     *
+     * Returns null when the player view has no subtitle view — a configuration this package does
+     * not produce, but `PlayerView` allows.
+     */
+    /** Removes the overlay from [playerView], dropping its listener registration with it. */
+    fun remove(playerView: PlayerView) {
+      val parent = playerView.subtitleView?.parent as? ViewGroup ?: return
+      for (index in 0 until parent.childCount) {
+        val overlay = parent.getChildAt(index) as? AssSignOverlay ?: continue
+        overlay.detach()
+        parent.removeView(overlay)
+        return
+      }
+    }
+
+    fun install(playerView: PlayerView): AssSignOverlay? {
+      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 }
+      }
+
+      val overlay = AssSignOverlay(playerView.context)
+      // Directly in front of the captions: a sign belongs to the picture, and the dialogue box
+      // should not be able to cover it.
+      parent.addView(overlay, parent.indexOfChild(subtitleView) + 1, ViewGroup.LayoutParams(
+        ViewGroup.LayoutParams.MATCH_PARENT,
+        ViewGroup.LayoutParams.MATCH_PARENT,
+      ))
+      return overlay
+    }
+  }
+}

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

@@ -0,0 +1,510 @@
+package expo.modules.video.utils
+
+/**
+ * Reads the typesetting out of an ASS script: the events that are drawn *onto the picture* rather
+ * than laid out at the bottom, and the transforms that put them there.
+ *
+ * ### Why this exists at all
+ *
+ * Media3 cannot render a rotated caption. `SubtitlePainter` contains no call to `rotate`, `skew`,
+ * `Matrix` or `Camera`, and `Cue` has no rotation field — only `shearDegrees`, which the painter
+ * ignores. `SsaParser` never reads the tags either: `SsaStyle.Overrides` parses `\pos`, `\move` and
+ * `\an` and discards every other override block.
+ *
+ * That is fine for dialogue and wrong for signs. In one episode of Jujutsu Kaisen S3, 3,723 events
+ * carry `\frz` — 1,304 of them past 5°, 104 past 45° — because the placards they sit on are drawn
+ * at an angle and the translation has to lie on the placard. Rendered flat, the text reads as
+ * pasted over the artwork instead of part of it.
+ *
+ * So signs are taken out of Media3's hands. This parser produces them; [AssSignOverlay] draws them
+ * with Android's own view transforms, which map onto ASS almost one for one.
+ *
+ * ### What counts as a sign
+ *
+ * Anything the author placed: an event carrying `\pos` or `\move`, or whose effective alignment is
+ * not bottom-centre. The complement — no positioning tag, alignment 2 — is dialogue, and is exactly
+ * the set [SsaCueNormalizer] recognises, so the two agree on every event and nothing is drawn twice
+ * or dropped.
+ *
+ * ### What is deliberately not read
+ *
+ * `\t` animation, `\fad`, `\clip`, `\blur`, `\be`, vector drawings and karaoke. Those need a real
+ * ASS renderer. This is a subset chosen because it is what the eye notices first: where the text
+ * is, which way it faces, how big it is, and whether it is fading.
+ */
+internal object AssSignParser {
+
+  private const val DEFAULT_PLAY_RES_X = 384f
+  private const val DEFAULT_PLAY_RES_Y = 288f
+
+  /**
+   * Matches one override block, `{…}`. The contents are scanned separately.
+   *
+   * Both braces are escaped. A bare closing brace is legal in `java.util.regex` and a syntax error
+   * in ICU, which is the engine Android actually uses — so the unescaped form compiles and passes
+   * on a JVM test run, then throws `PatternSyntaxException` from a static initialiser on device and
+   * takes the playback thread down with it.
+   */
+  private val BRACES = Regex("""\{([^}]*)\}""")
+
+  /**
+   * Splits a script into the part this package draws and the part Media3 draws.
+   *
+   * Both come out of one pass. Handing the delegate a copy with the sign lines removed is what
+   * makes double-drawing structurally impossible — there is no matching step to get wrong, because
+   * an event is in exactly one of the two outputs.
+   */
+  fun parse(content: String): AssScript {
+    var playResX = DEFAULT_PLAY_RES_X
+    var playResY = DEFAULT_PLAY_RES_Y
+    var sawX = false
+    var sawY = false
+
+    val styles = HashMap<String, AssStyle>()
+    val events = ArrayList<RawEvent>()
+    val sourceLines = content.split('\n')
+    // Line numbers of the Dialogue events, so the ones this package takes over can be cut out of
+    // the copy handed to the delegate.
+    val eventLines = ArrayList<Int>()
+
+    var section = ""
+    var styleFields: List<String> = emptyList()
+    var eventFields: List<String> = emptyList()
+    var legacyStyles = false
+
+    for ((lineNumber, rawLine) in sourceLines.withIndex()) {
+      val line = rawLine.trim()
+      if (line.isEmpty() || line.startsWith(";")) continue
+
+      if (line.startsWith("[") && line.endsWith("]")) {
+        section = line.lowercase()
+        legacyStyles = section == "[v4 styles]"
+        continue
+      }
+
+      // First colon only: a Title: may contain colons of its own.
+      val colon = line.indexOf(':')
+      if (colon == -1) continue
+      val key = line.substring(0, colon).trim()
+      val value = line.substring(colon + 1).trim()
+
+      when (section) {
+        "[script info]" -> when {
+          key.equals("PlayResX", true) -> value.toFloatOrNull()?.takeIf { it > 0 }?.let { playResX = it; sawX = true }
+          key.equals("PlayResY", true) -> value.toFloatOrNull()?.takeIf { it > 0 }?.let { playResY = it; sawY = true }
+        }
+
+        "[v4+ styles]", "[v4 styles]" -> when {
+          key.equals("Format", true) -> styleFields = value.split(',').map { it.trim().lowercase() }
+          key.equals("Style", true) && styleFields.isNotEmpty() ->
+            readStyle(value, styleFields, legacyStyles)?.let { styles[it.first] = it.second }
+        }
+
+        "[events]" -> when {
+          key.equals("Format", true) -> eventFields = value.split(',').map { it.trim().lowercase() }
+          // Only Dialogue reaches the screen. Comment holds notes and unused alternates.
+          key.equals("Dialogue", true) && eventFields.isNotEmpty() ->
+            readEvent(value, eventFields)?.let { events.add(it); eventLines.add(lineNumber) }
+        }
+      }
+    }
+
+    // VSFilter's rule: one dimension given, derive the other at 4:3.
+    if (sawX && !sawY) playResY = playResX * 3f / 4f
+    if (sawY && !sawX) playResX = playResY * 4f / 3f
+
+    val signs = ArrayList<AssSign>()
+    val removed = HashSet<Int>()
+    for ((index, event) in events.withIndex()) {
+      when (val resolution = resolve(event, styles, playResX, playResY)) {
+        is Resolution.Sign -> {
+          signs.add(resolution.sign)
+          removed.add(eventLines[index])
+        }
+        // Invisible styles, vector drawings and events with nothing to read. Media3 would render
+        // the first two as text.
+        Resolution.Drop -> removed.add(eventLines[index])
+        Resolution.Dialogue -> Unit
+      }
+    }
+
+    val dialogueOnly = if (removed.isEmpty()) {
+      content
+    } else {
+      sourceLines.filterIndexed { index, _ -> index !in removed }.joinToString("\n")
+    }
+
+    return AssScript(playResX, playResY, signs, dialogueOnly)
+  }
+
+  private sealed interface Resolution {
+    /** Typeset by the author; drawn by [AssSignOverlay]. */
+    data class Sign(val sign: AssSign) : Resolution
+
+    /** Bottom-centre with no positioning tag; left to Media3. */
+    data object Dialogue : Resolution
+
+    /** Renders nothing, or renders something no viewer was meant to read. */
+    data object Drop : Resolution
+  }
+
+  // ---------------------------------------------------------------------------------------------
+  // Styles
+  // ---------------------------------------------------------------------------------------------
+
+  private fun readStyle(value: String, fields: List<String>, legacy: Boolean): Pair<String, AssStyle>? {
+    val parts = value.split(',').map { it.trim() }
+    fun field(name: String): String? = fields.indexOf(name).takeIf { it >= 0 && it < parts.size }?.let { parts[it] }
+
+    val name = field("name") ?: return null
+    val rawAlignment = field("alignment")?.toIntOrNull() ?: 2
+    val alignment = if (legacy) legacyAlignment(rawAlignment) else rawAlignment.takeIf { it in 1..9 } ?: 2
+
+    val fontSize = field("fontsize")?.toFloatOrNull() ?: 48f
+    val primary = parseAssColour(field("primarycolour"))
+    val outline = parseAssColour(field("outlinecolour"))
+
+    return name to AssStyle(
+      alignment = alignment,
+      fontSize = fontSize,
+      colour = primary?.rgb ?: 0xFFFFFF,
+      alpha = primary?.alpha ?: 1f,
+      outlineColour = outline?.rgb ?: 0x000000,
+      outlineAlpha = outline?.alpha ?: 1f,
+      outlineWidth = field("outline")?.toFloatOrNull() ?: 0f,
+      bold = field("bold") == "-1",
+      italic = field("italic") == "-1",
+      underline = field("underline") == "-1",
+      scaleX = (field("scalex")?.toFloatOrNull() ?: 100f) / 100f,
+      scaleY = (field("scaley")?.toFloatOrNull() ?: 100f) / 100f,
+      angle = field("angle")?.toFloatOrNull() ?: 0f,
+      marginL = field("marginl")?.toFloatOrNull() ?: 0f,
+      marginR = field("marginr")?.toFloatOrNull() ?: 0f,
+      marginV = field("marginv")?.toFloatOrNull() ?: 0f,
+      // Fontsize 0 or a fully transparent primary colour is how a typesetter parks working notes
+      // in a script they still have to ship. See SsaCueNormalizer for the same rule on the Media3
+      // side; both have to agree or the notes come back on one path and not the other.
+      invisible = fontSize <= 0f || (primary?.alpha ?: 1f) == 0f,
+    )
+  }
+
+  /** SSA v4 packs the vertical into bits (+4 top, +8 middle) instead of using the numpad. */
+  private fun legacyAlignment(raw: Int): Int {
+    val horizontal = raw and 0x3
+    val h = when (horizontal) {
+      1 -> 1; 2 -> 2; 3 -> 3
+      else -> 2
+    }
+    return when {
+      raw and 0x8 != 0 -> h + 3  // middle
+      raw and 0x4 != 0 -> h + 6  // top
+      else -> h                  // bottom
+    }
+  }
+
+  // ---------------------------------------------------------------------------------------------
+  // Events
+  // ---------------------------------------------------------------------------------------------
+
+  private fun readEvent(value: String, fields: List<String>): RawEvent? {
+    val textIndex = fields.indexOf("text")
+    if (textIndex == -1) return null
+
+    // The Text column is last by definition and may contain commas, so split on the first N only
+    // and take the whole remainder. Splitting on every comma is how a line of dialogue loses its
+    // second half.
+    val parts = value.split(',', limit = fields.size)
+    if (parts.size <= textIndex) return null
+    fun field(name: String): String? = fields.indexOf(name).takeIf { it >= 0 && it < parts.size }?.let { parts[it].trim() }
+
+    val start = parseTimeUs(field("start") ?: return null) ?: return null
+    val end = parseTimeUs(field("end") ?: return null) ?: return null
+    if (end <= start) return null
+
+    return RawEvent(
+      startUs = start,
+      endUs = end,
+      styleName = field("style") ?: "Default",
+      marginL = field("marginl")?.toFloatOrNull() ?: 0f,
+      marginR = field("marginr")?.toFloatOrNull() ?: 0f,
+      marginV = field("marginv")?.toFloatOrNull() ?: 0f,
+      raw = parts[textIndex],
+    )
+  }
+
+  /** `H:MM:SS.cc`, centiseconds. */
+  private fun parseTimeUs(value: String): Long? {
+    val parts = value.split(':')
+    if (parts.size != 3) return null
+    val h = parts[0].trim().toLongOrNull() ?: return null
+    val m = parts[1].trim().toLongOrNull() ?: return null
+    val s = parts[2].trim().toDoubleOrNull() ?: return null
+    return ((h * 3600 + m * 60) * 1_000_000L) + (s * 1_000_000.0).toLong()
+  }
+
+  // ---------------------------------------------------------------------------------------------
+  // Overrides
+  // ---------------------------------------------------------------------------------------------
+
+  private fun resolve(event: RawEvent, styles: Map<String, AssStyle>, resX: Float, resY: Float): Resolution {
+    val style = styles[event.styleName] ?: AssStyle.DEFAULT
+    if (style.invisible) return Resolution.Drop
+
+    var alignment = style.alignment
+    var posX: Float? = null
+    var posY: Float? = null
+    var orgX: Float? = null
+    var orgY: Float? = null
+    var frz = style.angle
+    var frx = 0f
+    var fry = 0f
+    var fscx = style.scaleX
+    var fscy = style.scaleY
+    var fontSize = style.fontSize
+    var colour = style.colour
+    var alpha = style.alpha
+    var bold = style.bold
+    var italic = style.italic
+    var underline = style.underline
+    var drawing = false
+
+    for (block in BRACES.findAll(event.raw)) {
+      val body = block.groupValues[1]
+      for (tag in scanTags(body)) {
+        when (tag.name) {
+          "an" -> tag.arg.toIntOrNull()?.takeIf { it in 1..9 }?.let { alignment = it }
+          "a" -> tag.arg.toIntOrNull()?.let { alignment = legacyAlignment(it) }
+          "pos" -> readPoint(tag.arg)?.let { posX = it.first; posY = it.second }
+          // A move ends where it ends; drawing it at the destination beats drawing it at the start.
+          "move" -> readPoint(tag.arg, from = 2)?.let { posX = it.first; posY = it.second }
+          "org" -> readPoint(tag.arg)?.let { orgX = it.first; orgY = it.second }
+          "frz", "fr" -> tag.arg.toFloatOrNull()?.let { frz = it }
+          "frx" -> tag.arg.toFloatOrNull()?.let { frx = it }
+          "fry" -> tag.arg.toFloatOrNull()?.let { fry = it }
+          "fscx" -> tag.arg.toFloatOrNull()?.let { fscx = it / 100f }
+          "fscy" -> tag.arg.toFloatOrNull()?.let { fscy = it / 100f }
+          "fs" -> tag.arg.toFloatOrNull()?.takeIf { it > 0 }?.let { fontSize = it }
+          "c", "1c" -> parseAssColour(tag.arg)?.let { colour = it.rgb }
+          "alpha", "1a" -> parseAssColour(tag.arg, alphaOnly = true)?.let { alpha = it.alpha }
+          "b" -> bold = tag.arg.trim() != "0"
+          "i" -> italic = tag.arg.trim() == "1"
+          "u" -> underline = tag.arg.trim() == "1"
+          // A \p with a non-zero argument switches the text into vector drawing commands. Digits
+          // are required so \pos and \pbo are not mistaken for it.
+          "p" -> if ((tag.arg.toIntOrNull() ?: 0) > 0) drawing = true
+        }
+      }
+    }
+
+    if (drawing) return Resolution.Drop
+
+    val text = strip(event.raw)
+    if (text.isBlank()) return Resolution.Drop
+
+    val hasPosition = posX != null && posY != null
+    // The complement of SsaCueNormalizer's dialogue test. Anything it would clear stays with
+    // Media3; everything else is a sign and is drawn here.
+    if (!hasPosition && alignment == 2) return Resolution.Dialogue
+
+    val marginL = if (event.marginL != 0f) event.marginL else style.marginL
+    val marginR = if (event.marginR != 0f) event.marginR else style.marginR
+    val marginV = if (event.marginV != 0f) event.marginV else style.marginV
+
+    val x = posX ?: when ((alignment - 1) % 3) {
+      0 -> marginL
+      2 -> resX - marginR
+      else -> resX / 2f
+    }
+    val y = posY ?: when ((alignment - 1) / 3) {
+      0 -> resY - marginV
+      2 -> marginV
+      else -> resY / 2f
+    }
+
+    return Resolution.Sign(AssSign(
+      startUs = event.startUs,
+      endUs = event.endUs,
+      text = text,
+      x = x,
+      y = y,
+      alignment = alignment,
+      // ASS measures counter-clockwise, Android clockwise.
+      rotationZ = -frz,
+      // The two 3-D axes are a guess at the sign convention and are unverified on a device. They
+      // are kept because they are almost always tiny — in the episode this was built against, 3,363
+      // of 5,126 \frx values and 2,715 of 3,579 \fry values are under 3° — so getting a sign wrong
+      // is a subtle wrongness rather than a visible one. \frz is the one that carries the effect.
+      rotationX = frx,
+      rotationY = -fry,
+      pivotX = orgX ?: x,
+      pivotY = orgY ?: y,
+      scaleX = fscx,
+      scaleY = fscy,
+      fontSize = fontSize,
+      colour = colour,
+      alpha = alpha,
+      outlineColour = style.outlineColour,
+      outlineWidth = style.outlineWidth,
+      bold = bold,
+      italic = italic,
+      underline = underline,
+      playResX = resX,
+      playResY = resY,
+    ))
+  }
+
+  private data class Tag(val name: String, val arg: String)
+
+  /**
+   * Reads `\name arg` pairs out of one override block, left to right.
+   *
+   * Longest name wins, which is the whole reason this is a scanner and not a list of regexes: `\c`
+   * must not swallow `\clip`, and `\b` must not swallow `\bord`, `\blur` or `\be`.
+   */
+  private fun scanTags(body: String): List<Tag> {
+    val tags = ArrayList<Tag>()
+    var i = 0
+    while (i < body.length) {
+      if (body[i] != '\\') { i++; continue }
+      i++
+      val nameStart = i
+      // A leading digit is part of the name, not the argument: \1c, \3a and \4c all start with
+      // one. Letters then run to the end of the name, longest first, which is what keeps \c from
+      // swallowing \clip and \b from swallowing \bord, \blur and \be.
+      while (i < body.length && body[i].isDigit()) i++
+      while (i < body.length && body[i].isLetter()) i++
+      val name = body.substring(nameStart, i).lowercase()
+      if (name.isEmpty()) continue
+
+      val argStart = i
+      if (i < body.length && body[i] == '(') {
+        var depth = 0
+        while (i < body.length) {
+          if (body[i] == '(') depth++
+          if (body[i] == ')') { depth--; if (depth == 0) { i++; break } }
+          i++
+        }
+        tags.add(Tag(name, body.substring(argStart + 1, (i - 1).coerceAtLeast(argStart + 1))))
+      } else {
+        while (i < body.length && body[i] != '\\') i++
+        tags.add(Tag(name, body.substring(argStart, i)))
+      }
+    }
+    return tags
+  }
+
+  private fun readPoint(arg: String, from: Int = 0): Pair<Float, Float>? {
+    val parts = arg.split(',').map { it.trim() }
+    if (parts.size < from + 2) return null
+    val x = parts[from].toFloatOrNull() ?: return null
+    val y = parts[from + 1].toFloatOrNull() ?: return null
+    return x to y
+  }
+
+  /** Override blocks out, ASS escapes in. Mirrors what `SsaParser` does to the same string. */
+  private fun strip(raw: String): String =
+    BRACES.replace(raw, "")
+      .replace("\\N", "\n")
+      .replace("\\n", "\n")
+      .replace("\\h", " ")
+
+  internal data class AssColour(val rgb: Int, val alpha: Float)
+
+  /**
+   * `&HAABBGGRR&` or `&HBBGGRR&`, with or without the ampersands, or a bare decimal.
+   *
+   * The alpha byte is inverted in ASS — `FF` is fully transparent — and is absent from a six-digit
+   * value, which is therefore opaque.
+   */
+  internal fun parseAssColour(value: String?, alphaOnly: Boolean = false): AssColour? {
+    var text = value?.trim()?.removeSuffix("&") ?: return null
+    text = if (text.startsWith("&H", true)) text.substring(2) else text
+    if (text.isEmpty()) return null
+
+    val hex = text.toLongOrNull(16) ?: return null
+    if (alphaOnly || text.length <= 2) {
+      return AssColour(rgb = 0xFFFFFF, alpha = 1f - ((hex and 0xFF) / 255f))
+    }
+
+    val rgb = (((hex and 0xFF) shl 16) or (((hex shr 8) and 0xFF) shl 8) or ((hex shr 16) and 0xFF)).toInt()
+    val alpha = if (text.length > 6) 1f - (((hex shr 24) and 0xFF) / 255f) else 1f
+    return AssColour(rgb, alpha)
+  }
+
+  private data class RawEvent(
+    val startUs: Long,
+    val endUs: Long,
+    val styleName: String,
+    val marginL: Float,
+    val marginR: Float,
+    val marginV: Float,
+    val raw: String,
+  )
+}
+
+internal data class AssStyle(
+  val alignment: Int,
+  val fontSize: Float,
+  val colour: Int,
+  val alpha: Float,
+  val outlineColour: Int,
+  val outlineAlpha: Float,
+  val outlineWidth: Float,
+  val bold: Boolean,
+  val italic: Boolean,
+  val underline: Boolean,
+  val scaleX: Float,
+  val scaleY: Float,
+  val angle: Float,
+  val marginL: Float,
+  val marginR: Float,
+  val marginV: Float,
+  val invisible: Boolean,
+) {
+  companion object {
+    val DEFAULT = AssStyle(
+      alignment = 2, fontSize = 48f, colour = 0xFFFFFF, alpha = 1f,
+      outlineColour = 0x000000, outlineAlpha = 1f, outlineWidth = 0f,
+      bold = false, italic = false, underline = false,
+      scaleX = 1f, scaleY = 1f, angle = 0f,
+      marginL = 0f, marginR = 0f, marginV = 0f, invisible = false,
+    )
+  }
+}
+
+/** One typeset event, in script coordinates. [AssSignOverlay] maps it onto the video rect. */
+internal data class AssSign(
+  val startUs: Long,
+  val endUs: Long,
+  val text: String,
+  val x: Float,
+  val y: Float,
+  val alignment: Int,
+  val rotationZ: Float,
+  val rotationX: Float,
+  val rotationY: Float,
+  val pivotX: Float,
+  val pivotY: Float,
+  val scaleX: Float,
+  val scaleY: Float,
+  val fontSize: Float,
+  val colour: Int,
+  val alpha: Float,
+  val outlineColour: Int,
+  val outlineWidth: Float,
+  val bold: Boolean,
+  val italic: Boolean,
+  val underline: Boolean,
+  /** The coordinate space x, y, pivot and fontSize are expressed in. */
+  val playResX: Float,
+  val playResY: Float,
+)
+
+internal data class AssScript(
+  val playResX: Float,
+  val playResY: Float,
+  /** Typeset events, drawn by [AssSignOverlay]. */
+  val signs: List<AssSign>,
+  /** The script with every sign, drawing and invisible event cut out, for Media3's own parser. */
+  val dialogueOnly: String,
+)

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

@@ -0,0 +1,23 @@
+package expo.modules.video.utils
+
+/**
+ * Carries one parsed ASS sign through Media3's cue stream to [AssSignOverlay].
+ *
+ * The cue itself is a single zero-width character, so `SubtitleView` lays it out and draws nothing
+ * while the overlay reads the sign off this span and draws it properly. Riding the cue stream is
+ * what buys the timing for free: Media3 already decides which cues are on screen at each moment,
+ * and a sign is on screen exactly as long as its cue is.
+ *
+ * A marker span rather than a field on `Cue` because `Cue` is final and carries no room for one —
+ * it has `shearDegrees` and nothing else transform-shaped, and `SubtitlePainter` ignores even that.
+ */
+internal class AssSignSpan(val sign: AssSign)
+
+/**
+ * The cue text a sign rides on.
+ *
+ * A zero-width space still occupies a line of height in `SubtitleView`, which is harmless for a
+ * positioned cue and keeps the span anchored to something. Distinct from [HELD_SLOT_PLACEHOLDER]
+ * only in intent; both are invisible.
+ */
+internal const val SIGN_CUE_PLACEHOLDER = "​"

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

@@ -191,6 +191,9 @@ class RoundedSubtitleBackground private constructor(private val backgroundView:
    */
   private fun toBackgroundCue(cue: Cue): Cue? {
     val text = cue.text ?: return null // Bitmap cues carry no text to put a box behind.
+    // A sign's cue is a zero-width placeholder standing in for text drawn by `AssSignOverlay`.
+    // There is no glyph here to sit behind, and the box would be the only thing on screen.
+    if (text is Spanned && text.getSpans(0, text.length, AssSignSpan::class.java).isNotEmpty()) return null
     val stripped = if (keepMetricSpans && text is Spanned) {
       SpannableString(text).also { spannable ->
         for (span in spannable.getSpans(0, spannable.length, Any::class.java)) {

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

@@ -1,12 +1,15 @@
 package expo.modules.video.utils
 
+import android.text.SpannableString
 import android.text.SpannableStringBuilder
+import android.text.Spanned
 import androidx.annotation.OptIn
 import androidx.media3.common.C
 import androidx.media3.common.Format
 import androidx.media3.common.MimeTypes
 import androidx.media3.common.text.Cue
 import androidx.media3.common.util.Consumer
+import androidx.media3.common.util.Log
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.extractor.text.CuesWithTiming
 import androidx.media3.extractor.text.DefaultSubtitleParserFactory
@@ -73,6 +76,26 @@ open class StackingSubtitleParser(
   private val prepare: (Cue) -> Cue? = { it },
 ) : SubtitleParser {
 
+  /**
+   * A chance for a subclass to take some events out of the delegate's hands and supply its own cues
+   * for them. Returns the bytes the delegate should parse plus the cues the subclass is drawing.
+   *
+   * Default is to change nothing.
+   */
+  protected open fun split(data: ByteArray, offset: Int, length: Int): Split =
+    Split(data, offset, length, emptyList())
+
+  /** [split]'s result: what the delegate parses, and what the subclass contributes. */
+  protected class Split(
+    val data: ByteArray,
+    val offset: Int,
+    val length: Int,
+    val ownCues: List<PreparedCue>,
+  )
+
+  /** One cue a subclass supplies, with the timing the delegate would otherwise have derived. */
+  protected class PreparedCue(val cue: Cue, val startUs: Long, val endUs: Long)
+
   // Every emitted segment is a complete description of what should be on screen for its interval,
   // so segments replace each other rather than being merged by the renderer.
   override fun getCueReplacementBehavior(): Int = Format.CUE_REPLACEMENT_BEHAVIOR_REPLACE
@@ -89,9 +112,13 @@ open class StackingSubtitleParser(
     output: Consumer<CuesWithTiming>
   ) {
     val entries = mutableListOf<Entry>()
+    val split = split(data, offset, length)
+    for (prepared in split.ownCues) {
+      entries.add(Entry(prepared.cue, prepared.startUs, prepared.endUs, entries.size))
+    }
     // Always ask the delegate for everything; `outputOptions` is applied to the merged result below,
     // because a segment can span cues that fall on both sides of the requested start time.
-    delegate.parse(data, offset, length, SubtitleParser.OutputOptions.allCues()) { cuesWithTiming ->
+    delegate.parse(split.data, split.offset, split.length, SubtitleParser.OutputOptions.allCues()) { cuesWithTiming ->
       val startUs = cuesWithTiming.startTimeUs
       val endUs = resolveEndUs(cuesWithTiming)
       for (cue in cuesWithTiming.cues) {
@@ -291,7 +318,16 @@ open class StackingSubtitleParser(
 class StackingSubripParser : StackingSubtitleParser(SubripParser())
 
 /**
- * ASS and SSA, via [SsaCueNormalizer].
+ * ASS and SSA.
+ *
+ * Splits the script in two before anything else runs. [AssSignParser] takes the typeset events —
+ * anything the author placed — and the delegate gets a copy with those lines removed, so the two
+ * renderers can never draw the same event. Signs come back as cues carrying an [AssSignSpan], which
+ * rides Media3's own timing all the way to [AssSignOverlay]; the cue text itself is a zero-width
+ * character, so `SubtitleView` lays it out and draws nothing.
+ *
+ * Falls back to plain delegation when the script yields no signs, which is every `.ass` that is
+ * only dialogue, and when the bytes are not decodable as text.
  *
  * The delegate is built by the caller rather than constructed here because an SSA track muxed into
  * a container carries its `[V4+ Styles]` header in the format's initialization data, and only
@@ -299,7 +335,50 @@ class StackingSubripParser : StackingSubtitleParser(SubripParser())
  */
 @OptIn(UnstableApi::class)
 class StackingSsaParser(delegate: SubtitleParser) :
-  StackingSubtitleParser(delegate, SsaCueNormalizer::normalize)
+  StackingSubtitleParser(delegate, SsaCueNormalizer::normalize) {
+
+  override fun split(data: ByteArray, offset: Int, length: Int): Split {
+    // Nothing in here is worth a crash, and the whole body is inside the guard rather than just the
+    // parse. This runs on the extractor's loading thread, where an exception does not fail the
+    // subtitle — it takes playback down with it, which is how a stray `}` in a regex turned into a
+    // dead player on an episode that had been playing fine.
+    //
+    // A subtitle file is untrusted input from a scraper. The honest failure for one this cannot
+    // read is captions drawn Media3's own way, flat, rather than no video at all.
+    return runCatching {
+      val script = AssSignParser.parse(String(data, offset, length, Charsets.UTF_8))
+      if (script.signs.isEmpty()) {
+        Split(data, offset, length, emptyList())
+      } else {
+        val dialogue = script.dialogueOnly.toByteArray(Charsets.UTF_8)
+        Split(dialogue, 0, dialogue.size, script.signs.map(::toEntry))
+      }
+    }.getOrElse { error ->
+      Log.w(TAG, "Sign rendering unavailable for this track; falling back to Media3", error)
+      Split(data, offset, length, emptyList())
+    }
+  }
+
+  private companion object {
+    const val TAG = "StackingSsaParser"
+  }
+
+  private fun toEntry(sign: AssSign): PreparedCue {
+    val text = SpannableString(SIGN_CUE_PLACEHOLDER)
+    text.setSpan(AssSignSpan(sign), 0, text.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+
+    // Positioned so the stacking pass leaves it alone and the span filter keeps it intact. The
+    // values are only a rough placement for the invisible placeholder; the overlay reads the real
+    // coordinates off the span.
+    val cue = Cue.Builder()
+      .setText(text)
+      .setPosition((sign.x / sign.playResX).coerceIn(0f, 1f))
+      .setLine((sign.y / sign.playResY).coerceIn(0f, 1f), Cue.LINE_TYPE_FRACTION)
+      .build()
+
+    return PreparedCue(cue, sign.startUs, sign.endUs)
+  }
+}
 
 /**
  * Routes SubRip and ASS/SSA through the stacking parsers so simultaneous cues stack, delegates every

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

@@ -98,6 +98,12 @@ object SubtitleUtils {
       if (!roundedBackgroundApplied) {
         RoundedSubtitleBackground.remove(playerView)
       }
+
+      // Independent of every style decision above: an ASS sign is drawn where and how the script
+      // says, not how the viewer's caption settings say, so nothing here applies to it. Installed
+      // unconditionally because the track can be switched to an `.ass` at any point, and rebinding
+      // on each reconfigure is what carries it across a player swap.
+      AssSignOverlay.install(playerView)?.attachTo(playerView.player)
     }
   }
 
@@ -108,6 +114,7 @@ object SubtitleUtils {
    */
   fun releaseSubtitleView(playerView: PlayerView) {
     RoundedSubtitleBackground.remove(playerView)
+    AssSignOverlay.remove(playerView)
   }
 
   /**

package/package.json

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