fix(player): prevent subtitle overlap and restore zlib subtitle samples

player-core/src/main/kotlin/com/miruplay/tv/player/DiModule.kt

@@ -30,7 +30,9 @@ object PlayerModule {
             .setMediaCodecSelector(PlaybackMediaCodecSelector)
 
         return ExoPlayer.Builder(context, renderersFactory)
-            .setMediaSourceFactory(DefaultMediaSourceFactory(dataSourceFactory))
+            .setMediaSourceFactory(
+                DefaultMediaSourceFactory(dataSourceFactory, ZlibSubtitleExtractorsFactory()),
+            )
             .build()
     }
 
@@ -49,7 +51,9 @@ object PlayerModule {
             .setMediaCodecSelector(PlaybackMediaCodecSelector)
 
         return ExoPlayer.Builder(context, renderersFactory)
-            .setMediaSourceFactory(DefaultMediaSourceFactory(dataSourceFactory))
+            .setMediaSourceFactory(
+                DefaultMediaSourceFactory(dataSourceFactory, ZlibSubtitleExtractorsFactory()),
+            )
             .build()
     }
 

player-core/src/main/kotlin/com/miruplay/tv/player/ZlibSubtitleExtractor.kt

@@ -0,0 +1,128 @@
+package com.miruplay.tv.player
+
+import androidx.media3.common.Format
+import androidx.media3.common.util.Consumer
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.extractor.DefaultExtractorsFactory
+import androidx.media3.extractor.Extractor
+import androidx.media3.extractor.ExtractorsFactory
+import androidx.media3.extractor.text.DefaultSubtitleParserFactory
+import androidx.media3.extractor.text.SubtitleParser
+import java.io.ByteArrayOutputStream
+import java.util.zip.DataFormatException
+import java.util.zip.Inflater
+
+/**
+ * Media3 handles Matroska header stripping but not zlib-compressed subtitle samples.
+ * This factory keeps the stock extractors and inflates text samples before parsing.
+ */
+@UnstableApi
+internal class ZlibSubtitleExtractorsFactory(
+    private val delegate: DefaultExtractorsFactory = DefaultExtractorsFactory()
+        .setSubtitleParserFactory(ZlibSubtitleParserFactory(DefaultSubtitleParserFactory()))
+        .experimentalSetTextTrackTranscodingEnabled(true),
+) : ExtractorsFactory {
+
+    override fun createExtractors(): Array<Extractor> = delegate.createExtractors()
+
+    override fun experimentalSetTextTrackTranscodingEnabled(enabled: Boolean): ExtractorsFactory {
+        delegate.experimentalSetTextTrackTranscodingEnabled(enabled)
+        return this
+    }
+
+    override fun setSubtitleParserFactory(factory: SubtitleParser.Factory): ExtractorsFactory {
+        delegate.setSubtitleParserFactory(ZlibSubtitleParserFactory(factory))
+        return this
+    }
+}
+
+@UnstableApi
+private class ZlibSubtitleParserFactory(
+    private val delegate: SubtitleParser.Factory,
+) : SubtitleParser.Factory {
+
+    override fun supportsFormat(format: Format): Boolean = delegate.supportsFormat(format)
+
+    override fun getCueReplacementBehavior(format: Format): Int =
+        delegate.getCueReplacementBehavior(format)
+
+    override fun create(format: Format): SubtitleParser =
+        ZlibSubtitleParser(delegate.create(format))
+}
+
+@UnstableApi
+private class ZlibSubtitleParser(
+    private val delegate: SubtitleParser,
+) : SubtitleParser {
+
+    override fun parse(
+        data: ByteArray,
+        offset: Int,
+        length: Int,
+        outputOptions: SubtitleParser.OutputOptions,
+        output: Consumer<androidx.media3.extractor.text.CuesWithTiming>,
+    ) {
+        val sample = data.copyOfRange(offset, offset + length)
+        val inflated = inflateSubtitleSampleIfNeeded(sample)
+        delegate.parse(inflated, 0, inflated.size, outputOptions, output)
+    }
+
+    override fun getCueReplacementBehavior(): Int = delegate.getCueReplacementBehavior()
+
+    override fun reset() {
+        delegate.reset()
+    }
+}
+
+internal fun inflateSubtitleSampleIfNeeded(input: ByteArray): ByteArray {
+    if (input.size < 2) return input
+
+    for (start in 0..input.lastIndex - 1) {
+        if (!isZlibHeader(input, start)) continue
+        val inflated = inflateFrom(input, start) ?: continue
+        val candidate = input.copyOfRange(0, start) + inflated
+        if (looksLikeSubtitleText(candidate)) return candidate
+    }
+    return input
+}
+
+private fun isZlibHeader(input: ByteArray, index: Int): Boolean {
+    val compressionMethod = input[index].toInt() and 0x0F
+    val flags = input[index + 1].toInt() and 0xFF
+    val header = ((input[index].toInt() and 0xFF) shl 8) or flags
+    return compressionMethod == 8 && header % 31 == 0
+}
+
+private fun inflateFrom(input: ByteArray, start: Int): ByteArray? {
+    val inflater = Inflater()
+    return try {
+        inflater.setInput(input, start, input.size - start)
+        val output = ByteArrayOutputStream(maxOf(32, (input.size - start) * 2))
+        val buffer = ByteArray(8 * 1024)
+        while (!inflater.finished()) {
+            val count = inflater.inflate(buffer)
+            if (count > 0) {
+                output.write(buffer, 0, count)
+            } else if (inflater.needsDictionary() || inflater.needsInput()) {
+                return null
+            } else {
+                return null
+            }
+        }
+        output.toByteArray()
+    } catch (_: DataFormatException) {
+        null
+    } finally {
+        inflater.end()
+    }
+}
+
+private fun looksLikeSubtitleText(bytes: ByteArray): Boolean {
+    if (bytes.isEmpty()) return false
+    val text = bytes.toString(Charsets.UTF_8)
+    if (text.indexOf('\uFFFD') >= 0) return false
+    return text.contains("Dialogue:") ||
+        text.contains("--> ") ||
+        text.contains("WEBVTT") ||
+        text.contains("<tt")
+}

player-core/src/test/kotlin/com/miruplay/tv/player/ZlibSubtitleSampleTest.kt

@@ -0,0 +1,53 @@
+package com.miruplay.tv.player
+
+import java.util.zip.Deflater
+import org.junit.Assert.assertArrayEquals
+import org.junit.Test
+
+class ZlibSubtitleSampleTest {
+
+    @Test
+    fun `zlib compressed subtitle sample is inflated`() {
+        val ass = "Dialogue: 0,0:00:01.00,0:00:02.00,Default,,0,0,0,,Hello\n".toByteArray()
+
+        val result = inflateSubtitleSampleIfNeeded(deflate(ass))
+
+        assertArrayEquals(ass, result)
+    }
+
+    @Test
+    fun `matroska dialogue prefix is preserved while zlib payload is inflated`() {
+        val prefix = "Dialogue: 0:00:00:00,0:00:02:16,"
+        val payload = "Default,,0,0,0,,Hello\n".toByteArray()
+        val sample = prefix.toByteArray() + deflate(payload)
+
+        assertArrayEquals(
+            prefix.toByteArray() + payload,
+            inflateSubtitleSampleIfNeeded(sample),
+        )
+    }
+
+    @Test
+    fun `plain subtitle sample is returned unchanged`() {
+        val ass = "Dialogue: 0,0:00:01.00,0:00:02.00,Default,,0,0,0,,Hello\n".toByteArray()
+
+        assertArrayEquals(ass, inflateSubtitleSampleIfNeeded(ass))
+    }
+
+    @Test
+    fun `invalid compressed-looking sample is returned unchanged`() {
+        val bytes = byteArrayOf(0x78.toByte(), 0x9c.toByte(), 0x01, 0x02, 0x03)
+
+        assertArrayEquals(bytes, inflateSubtitleSampleIfNeeded(bytes))
+    }
+
+    private fun deflate(input: ByteArray): ByteArray {
+        val deflater = Deflater()
+        deflater.setInput(input)
+        deflater.finish()
+        val output = ByteArray(input.size + 64)
+        val length = deflater.deflate(output)
+        deflater.end()
+        return output.copyOf(length)
+    }
+}

player-mpv-android/src/main/kotlin/is/xyz/mpv/MiruMpvSurfaceView.kt

@@ -196,6 +196,10 @@ class MiruMpvSurfaceView @JvmOverloads constructor(
         MPVLib.setOptionString("hwdec-codecs", EMBEDDED_MPV_HWDEC_CODECS)
         MPVLib.setOptionString("vo", sessionOptions.vo)
         MPVLib.setOptionString("save-position-on-quit", "no")
+        // Keep authored ASS styles and positions intact; libass owns subtitle layout.
+        mpvSubtitleLayoutNormalisationOptions.forEach { (name, value) ->
+            MPVLib.setOptionString(name, value)
+        }
         applyColorPipelineProperties(sessionOptions)
         applyShaderProperties(sessionOptions.shaderPaths)
         sessionOptions.extraOptions.forEach { (name, value) ->

player-mpv-android/src/main/kotlin/is/xyz/mpv/MpvSubtitleLayout.kt

@@ -0,0 +1,4 @@
+package `is`.xyz.mpv
+
+/** mpv subtitle options intentionally left empty so libass keeps authored ASS layout. */
+internal val mpvSubtitleLayoutNormalisationOptions: List<Pair<String, String>> = emptyList()

player-mpv-android/src/test/kotlin/is/xyz/mpv/MpvSubtitleLayoutTest.kt

@@ -0,0 +1,15 @@
+package `is`.xyz.mpv
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class MpvSubtitleLayoutTest {
+
+    @Test
+    fun `subtitle layout leaves ass positioning to libass`() {
+        assertEquals(
+            emptyList<Pair<String, String>>(),
+            mpvSubtitleLayoutNormalisationOptions,
+        )
+    }
+}

ui-tv/src/main/kotlin/com/miruplay/tv/ui/player/PlayerScreen.kt

@@ -102,6 +102,8 @@ import androidx.core.view.doOnLayout
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.media3.ui.AspectRatioFrameLayout
+import androidx.media3.common.Player
+import androidx.media3.common.text.CueGroup
 import androidx.media3.ui.CaptionStyleCompat
 import androidx.media3.ui.PlayerView
 import androidx.annotation.LayoutRes
@@ -187,14 +189,21 @@ internal fun subtitleCaptionStyle(
         )
     }
 
-private fun PlayerView.applySubtitleBackgroundPreference(transparentBackground: Boolean) {
+private fun resolveSubtitleCaptionStyle(
+    context: Context,
+    transparentBackground: Boolean,
+): CaptionStyleCompat {
     val captioningManager = context.getSystemService(CaptioningManager::class.java)
     val baseStyle = captioningManager
         ?.takeIf { it.isEnabled }
         ?.userStyle
         ?.let(CaptionStyleCompat::createFromCaptionStyle)
         ?: CaptionStyleCompat.DEFAULT
-    subtitleView?.setStyle(subtitleCaptionStyle(baseStyle, transparentBackground))
+    return subtitleCaptionStyle(baseStyle, transparentBackground)
+}
+
+private fun PlayerView.applySubtitleBackgroundPreference(transparentBackground: Boolean) {
+    subtitleView?.setStyle(resolveSubtitleCaptionStyle(context, transparentBackground))
 }
 
 @OptIn(ExperimentalTvMaterial3Api::class, ExperimentalLayoutApi::class)
@@ -573,6 +582,20 @@ private fun PlayerScreenContent(
     ) {
         val player = viewModel.getPlayer()
         val usesNativeVideoHost = viewModel.usesVlcVideoLayout()
+        DisposableEffect(player) {
+            val cueListener = object : Player.Listener {
+                override fun onCues(cueGroup: CueGroup) {
+                    val normalizedCues = restackSubtitleCues(cueGroup.cues)
+                    // PlayerView owns the subtitle layer; post after its internal
+                    // listener so the normalized cues remain the final render input.
+                    playerViewRef?.subtitleView?.post {
+                        playerViewRef?.subtitleView?.setCues(normalizedCues)
+                    }
+                }
+            }
+            player?.addListener(cueListener)
+            onDispose { player?.removeListener(cueListener) }
+        }
         if (shouldShowExperimentalSurface) {
             AndroidView(
                 factory = { context ->
@@ -675,7 +698,7 @@ private fun PlayerScreenContent(
                      },
                      modifier = Modifier.fillMaxSize()
                  )
-             }
+            }
         } else {
             Box(
                 modifier = Modifier.fillMaxSize().background(Color.Black),