diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 7e3836854..19c747f56 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -197,8 +197,11 @@ dependencies {
   implementation(libs.androidx.compose.animation.graphics)
   implementation(libs.mediasession)
   implementation(libs.androidx.documentfile)
+  implementation(libs.androidx.datastore.core)
+  implementation(libs.androidx.datastore.preferences)
   implementation(libs.bundles.coil)
 
+
   implementation(platform(libs.koin.bom))
   implementation(libs.bundles.koin)
 
@@ -212,11 +215,21 @@ dependencies {
   implementation(libs.room.ktx)
 
   implementation(libs.kotlinx.immutable.collections)
+  implementation(libs.kotlinx.coroutines.guava)
   implementation(libs.kotlinx.serialization.json)
+
   implementation(libs.okhttp)
   implementation(libs.jsoup)
   implementation(libs.androidx.media3.common)
+  implementation(libs.androidx.media3.datasource.okhttp)
   implementation(libs.androidx.media3.effect)
+  implementation(libs.androidx.media3.exoplayer)
+  implementation(libs.androidx.media3.exoplayer.dash)
+  implementation(libs.androidx.media3.exoplayer.hls)
+  implementation(libs.androidx.media3.exoplayer.rtsp)
+  implementation(libs.androidx.media3.session)
+  implementation(libs.androidx.media3.ui)
+  implementation(libs.androidx.media3.ui.compose)
   implementation(libs.androidx.media3.transformer)
   implementation(platform(libs.sora.editor.bom))
   implementation(libs.sora.editor)
@@ -226,11 +239,17 @@ dependencies {
   coreLibraryDesugaring(libs.desugar.jdk.libs)
 
   implementation(libs.truetype.parser)
+  implementation(libs.juniversalchardet)
+  implementation(libs.ass.media)
   implementation(libs.fsaf)
+
+
   implementation(libs.mediainfo.lib)
   implementation("com.llamatik:library:1.4.0")
   
   implementation(files("libs/mpvlib.aar"))
+  implementation(files("libs/media3ext-release.aar"))
+
 
   // Network protocol libraries
   implementation(libs.smbj)
diff --git a/app/libs/media3ext-release.aar b/app/libs/media3ext-release.aar
new file mode 100644
index 000000000..5dac47408
Binary files /dev/null and b/app/libs/media3ext-release.aar differ
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 3959fcf22..90eef724a 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -332,6 +332,24 @@
                 <data android:pathPattern=".*" />
             </intent-filter>
         </activity>
+        <activity
+            android:name=".exoplayer.ExoPlayerActivity"
+            android:configChanges="keyboard|keyboardHidden|navigation|orientation|screenLayout|uiMode|screenSize|smallestScreenSize"
+            android:exported="false"
+            android:launchMode="singleTask"
+            android:resizeableActivity="true"
+            android:supportsPictureInPicture="true"
+            android:theme="@style/Theme.mpvrx.Player" />
+
+        <service
+            android:name=".exoplayer.ExoPlayerService"
+            android:exported="true"
+            android:foregroundServiceType="mediaPlayback">
+            <intent-filter>
+                <action android:name="androidx.media3.session.MediaSessionService"/>
+            </intent-filter>
+        </service>
+
         <activity android:name=".presentation.crash.CrashActivity" />
 
         <activity
diff --git a/app/src/main/java/app/gyrolet/mpvrx/App.kt b/app/src/main/java/app/gyrolet/mpvrx/App.kt
index bf7da7d4c..88800b9a1 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/App.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/App.kt
@@ -38,15 +38,21 @@ class App : Application() {
   override fun onCreate() {
     super.onCreate()
 
-    // Initialize Koin
-    startKoin {
-      androidContext(this@App)
-      modules(
-        PreferencesModule,
-        DatabaseModule,
-        FileManagerModule,
-        app.gyrolet.mpvrx.di.domainModule,
-      )
+    try {
+        android.util.Log.d("App", "Starting Koin...")
+        startKoin {
+          androidContext(this@App)
+          modules(
+            PreferencesModule,
+            DatabaseModule,
+            FileManagerModule,
+            app.gyrolet.mpvrx.di.domainModule,
+            app.gyrolet.mpvrx.exoplayer.di.exoPlayerModule,
+          )
+        }
+        android.util.Log.d("App", "Koin initialized successfully")
+    } catch (e: Exception) {
+        android.util.Log.e("App", "Koin initialization failed!", e)
     }
 
     Thread.setDefaultUncaughtExceptionHandler(GlobalExceptionHandler(applicationContext, CrashActivity::class.java))
diff --git a/app/src/main/java/app/gyrolet/mpvrx/preferences/AppearancePreferences.kt b/app/src/main/java/app/gyrolet/mpvrx/preferences/AppearancePreferences.kt
index 683ff9fda..539dacea6 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/preferences/AppearancePreferences.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/preferences/AppearancePreferences.kt
@@ -44,13 +44,13 @@ class AppearancePreferences(
   val topRightControls =
     preferenceStore.getString(
       "top_right_controls",
-      "CURRENT_CHAPTER,DECODER,AUDIO_TRACK,SUBTITLES,MORE_OPTIONS",
+      "CURRENT_CHAPTER,DECODER,AUDIO_TRACK,SUBTITLES,TIME_NETWORK,VIDEO_FILTERS,MORE_OPTIONS",
     )
 
   val bottomRightControls =
     preferenceStore.getString(
       "bottom_right_controls",
-      "FRAME_NAVIGATION,VIDEO_ZOOM,PICTURE_IN_PICTURE,ASPECT_RATIO",
+      "FRAME_NAVIGATION,VIDEO_ZOOM,PICTURE_IN_PICTURE,ASPECT_RATIO,AMBIENT_MODE",
     )
 
   val bottomLeftControls =
@@ -62,7 +62,7 @@ class AppearancePreferences(
   val portraitBottomControls =
     preferenceStore.getString(
       "portrait_bottom_controls",
-      "SCREEN_ROTATION,DECODER,AUDIO_TRACK,SUBTITLES,BOOKMARKS_CHAPTERS,PLAYBACK_SPEED,BACKGROUND_PLAYBACK,REPEAT_MODE,SHUFFLE,VIDEO_ZOOM,FRAME_NAVIGATION,ASPECT_RATIO,PICTURE_IN_PICTURE,LOCK_CONTROLS,MORE_OPTIONS",
+      "SCREEN_ROTATION,DECODER,AUDIO_TRACK,SUBTITLES,BOOKMARKS_CHAPTERS,PLAYBACK_SPEED,BACKGROUND_PLAYBACK,REPEAT_MODE,SHUFFLE,VIDEO_ZOOM,FRAME_NAVIGATION,ASPECT_RATIO,PICTURE_IN_PICTURE,LOCK_CONTROLS,TIME_NETWORK,AMBIENT_MODE,VIDEO_FILTERS,MORE_OPTIONS",
     )
 
   fun parseButtons(
diff --git a/app/src/main/java/app/gyrolet/mpvrx/preferences/PlayerButton.kt b/app/src/main/java/app/gyrolet/mpvrx/preferences/PlayerButton.kt
index 6b6865d1d..6b935dd1a 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/preferences/PlayerButton.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/preferences/PlayerButton.kt
@@ -36,6 +36,7 @@ enum class PlayerButton(
   BACKGROUND_PLAYBACK(Icons.Outlined.Headset),
   AMBIENT_MODE(Icons.Outlined.BlurOff),
   TIME_NETWORK(Icons.Default.AccessTime),
+  VIDEO_FILTERS(Icons.Default.Tune),
   NONE(Icons.Outlined.Bookmarks),
 }
 
@@ -82,5 +83,6 @@ fun getPlayerButtonLabel(button: PlayerButton): String =
     PlayerButton.BACKGROUND_PLAYBACK -> "Background Playback"
     PlayerButton.AMBIENT_MODE -> "Ambience Mode"
     PlayerButton.TIME_NETWORK -> "Time + Network"
+    PlayerButton.VIDEO_FILTERS -> "Video Filters"
     PlayerButton.NONE -> "None"
   }
diff --git a/app/src/main/java/app/gyrolet/mpvrx/preferences/PlayerPreferences.kt b/app/src/main/java/app/gyrolet/mpvrx/preferences/PlayerPreferences.kt
index e0c880402..4186e2363 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/preferences/PlayerPreferences.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/preferences/PlayerPreferences.kt
@@ -93,6 +93,8 @@ class PlayerPreferences(
   val keepScreenOnWhenPaused = preferenceStore.getBoolean("keep_screen_on_when_paused", false)
   val autoplayAfterScreenUnlock = preferenceStore.getBoolean("autoplay_after_screen_unlock", false)
 
+  val enableExoPlayer = preferenceStore.getBoolean("enable_exoplayer", false)
+
   // Custom Buttons - JSON List
   val customButtons = preferenceStore.getString("custom_buttons_json", "[]")
 
diff --git a/app/src/main/java/app/gyrolet/mpvrx/presentation/crash/CrashActivity.kt b/app/src/main/java/app/gyrolet/mpvrx/presentation/crash/CrashActivity.kt
index 1c5be52fd..cbc358a40 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/presentation/crash/CrashActivity.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/presentation/crash/CrashActivity.kt
@@ -32,7 +32,6 @@ import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.Button
 import androidx.compose.material3.FilledIconButton
-import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.NavigationBarDefaults
 import androidx.compose.material3.OutlinedButton
@@ -70,6 +69,7 @@ import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.koin.android.ext.android.inject
+import org.koin.core.context.GlobalContext
 import java.io.BufferedReader
 import java.io.File
 import java.io.InputStreamReader
@@ -81,21 +81,36 @@ class CrashActivity : ComponentActivity() {
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
+    val exception = intent.getStringExtra("exception") ?: "No exception provided"
+    android.util.Log.e("CrashActivity", "CRASH DETECTED: $exception")
     lifecycle.coroutineScope.launch {
       logcat = collectLogcat()
     }
     setContent {
-      val dark by appearancePreferences.darkMode.collectAsState()
-      val isSystemInDarkTheme = isSystemInDarkTheme()
-      val isDarkMode = dark == DarkMode.Dark || (dark == DarkMode.System && isSystemInDarkTheme)
-      enableEdgeToEdge(
-        SystemBarStyle.auto(
-          lightScrim = Color.White.toArgb(),
-          darkScrim = Color.Transparent.toArgb(),
-        ) { isDarkMode },
-      )
-      MpvrxTheme {
-        CrashScreen(intent.getStringExtra("exception") ?: "")
+      if (GlobalContext.getOrNull() != null) {
+        val dark by appearancePreferences.darkMode.collectAsState()
+        val isSystemInDarkTheme = isSystemInDarkTheme()
+        val isDarkMode = dark == DarkMode.Dark || (dark == DarkMode.System && isSystemInDarkTheme)
+        enableEdgeToEdge(
+          SystemBarStyle.auto(
+            lightScrim = Color.White.toArgb(),
+            darkScrim = Color.Transparent.toArgb(),
+          ) { isDarkMode },
+        )
+        MpvrxTheme {
+          CrashScreen(intent.getStringExtra("exception") ?: "")
+        }
+      } else {
+        val isDarkMode = isSystemInDarkTheme()
+        enableEdgeToEdge(
+          SystemBarStyle.auto(
+            lightScrim = Color.White.toArgb(),
+            darkScrim = Color.Transparent.toArgb(),
+          ) { isDarkMode },
+        )
+        MaterialTheme {
+          CrashScreen(intent.getStringExtra("exception") ?: "")
+        }
       }
     }
   }
diff --git a/app/src/main/java/app/gyrolet/mpvrx/presentation/crash/GlobalExceptionHandler.kt b/app/src/main/java/app/gyrolet/mpvrx/presentation/crash/GlobalExceptionHandler.kt
index d23e076b2..c79d583c3 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/presentation/crash/GlobalExceptionHandler.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/presentation/crash/GlobalExceptionHandler.kt
@@ -15,7 +15,9 @@ class GlobalExceptionHandler(
     val intent = Intent(context, activity)
     intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
     intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
-    intent.putExtra("exception", e.stackTraceToString())
+    val stackTrace = e.stackTraceToString()
+    android.util.Log.e("GlobalExceptionHandler", "CRASH DETECTED: $stackTrace")
+    intent.putExtra("exception", stackTrace)
     context.startActivity(intent)
     exitProcess(0)
   }
diff --git a/app/src/main/java/app/gyrolet/mpvrx/ui/icons/Icons.kt b/app/src/main/java/app/gyrolet/mpvrx/ui/icons/Icons.kt
index e5aa95389..24d2ebd49 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/ui/icons/Icons.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/ui/icons/Icons.kt
@@ -297,6 +297,9 @@ object Icons {
     val Refresh = Shared.Refresh
     val Remove = Shared.Remove
     val RemoveCircle = Shared.RemoveCircle
+    val Repeat = Shared.Repeat
+    val RepeatOn = Shared.RepeatOn
+    val RepeatOne = Shared.RepeatOne
     val ResetIso = Shared.ResetIso
     val RoundedCorner = Shared.RoundedCorner
     val ScreenRotation = Shared.ScreenRotation
@@ -422,6 +425,8 @@ object Icons {
     val PictureInPictureAlt = Shared.PictureInPictureAlt
     val PlaylistAdd = Shared.PlaylistAdd
     val Repeat = Shared.Repeat
+    val RepeatOn = Shared.RepeatOn
+    val RepeatOne = Shared.RepeatOne
     val ScreenRotation = Shared.ScreenRotation
     val Search = Shared.Search
     val Settings = Shared.Settings
diff --git a/app/src/main/java/app/gyrolet/mpvrx/ui/player/controls/PlayerControlsShared.kt b/app/src/main/java/app/gyrolet/mpvrx/ui/player/controls/PlayerControlsShared.kt
index 16c3befe2..55b691413 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/ui/player/controls/PlayerControlsShared.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/ui/player/controls/PlayerControlsShared.kt
@@ -917,6 +917,15 @@ fun RenderPlayerButton(
       }
     }
 
+    PlayerButton.VIDEO_FILTERS -> {
+      ControlsButton(
+        icon = Icons.Default.Tune,
+        onClick = { onOpenPanel(Panels.VideoFilters) },
+        color = if (hideBackground) controlColor else MaterialTheme.colorScheme.onSurface,
+        modifier = Modifier.size(buttonSize),
+      )
+    }
+
     PlayerButton.NONE -> { /* Do nothing */
     }
   }
diff --git a/app/src/main/java/app/gyrolet/mpvrx/ui/preferences/PreferencesScreen.kt b/app/src/main/java/app/gyrolet/mpvrx/ui/preferences/PreferencesScreen.kt
index b93c7be00..942fada46 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/ui/preferences/PreferencesScreen.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/ui/preferences/PreferencesScreen.kt
@@ -30,9 +30,19 @@ import app.gyrolet.mpvrx.R
 import app.gyrolet.mpvrx.presentation.Screen
 import app.gyrolet.mpvrx.ui.utils.LocalBackStack
 import app.gyrolet.mpvrx.ui.utils.popSafely
+import app.gyrolet.mpvrx.preferences.preference.collectAsState
 import kotlinx.serialization.Serializable
 import me.zhanghai.compose.preference.Preference
 import me.zhanghai.compose.preference.ProvidePreferenceLocals
+import org.koin.compose.koinInject
+import androidx.compose.runtime.getValue
+import app.gyrolet.mpvrx.exoplayer.settings.screens.medialibrary.ExoMediaLibraryPreferencesScreen
+import app.gyrolet.mpvrx.exoplayer.settings.screens.player.ExoPlayerPreferencesScreen
+import app.gyrolet.mpvrx.exoplayer.settings.screens.gesture.ExoGesturePreferencesScreen
+import app.gyrolet.mpvrx.exoplayer.settings.screens.decoder.ExoDecoderPreferencesScreen
+import app.gyrolet.mpvrx.exoplayer.settings.screens.audio.ExoAudioPreferencesScreen
+import app.gyrolet.mpvrx.exoplayer.settings.screens.subtitle.ExoSubtitlePreferencesScreen
+import app.gyrolet.mpvrx.exoplayer.settings.screens.general.ExoGeneralPreferencesScreen
 
 @Serializable
 object PreferencesScreen : Screen {
@@ -40,6 +50,11 @@ object PreferencesScreen : Screen {
   @Composable
   override fun Content() {
     val backstack = LocalBackStack.current
+    android.util.Log.d("PreferencesScreen", "Content() starting")
+    val playerPreferences = koinInject<app.gyrolet.mpvrx.preferences.PlayerPreferences>()
+    val enableExoPlayer by playerPreferences.enableExoPlayer.collectAsState()
+    android.util.Log.d("PreferencesScreen", "enableExoPlayer: $enableExoPlayer")
+
     Scaffold(
       topBar = {
         TopAppBar(
@@ -103,118 +118,314 @@ object PreferencesScreen : Screen {
           }
 
           // ── 1. Appearance ─────────────────────────────────────────────────
-          item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_appearance)) }
-          item {
-            PreferenceCard {
-              Preference(
-                title = { Text(stringResource(R.string.pref_appearance_title)) },
-                summary = { Text(stringResource(R.string.pref_appearance_summary), color = MaterialTheme.colorScheme.outline) },
-                icon = { Icon(Icons.Outlined.Palette, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
-                onClick = { backstack.add(AppearancePreferencesScreen) },
-              )
+          if (!enableExoPlayer) {
+            item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_appearance)) }
+            item {
+              PreferenceCard {
+                Preference(
+                  title = { Text(stringResource(R.string.pref_appearance_title)) },
+                  summary = {
+                    Text(
+                      stringResource(R.string.pref_appearance_summary),
+                      color = MaterialTheme.colorScheme.outline
+                    )
+                  },
+                  icon = {
+                    Icon(
+                      Icons.Outlined.Palette,
+                      contentDescription = null,
+                      tint = MaterialTheme.colorScheme.primary
+                    )
+                  },
+                  onClick = { backstack.add(AppearancePreferencesScreen) },
+                )
+              }
             }
           }
 
           // ── 2. Playback ───────────────────────────────────────────────────
-          item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_playback)) }
-          item {
-            PreferenceCard {
-              Preference(
-                title = { Text(stringResource(R.string.pref_player)) },
-                summary = { Text(stringResource(R.string.pref_player_summary), color = MaterialTheme.colorScheme.outline) },
-                icon = { Icon(Icons.Default.Slideshow, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
-                onClick = { backstack.add(PlayerPreferencesScreen) },
-              )
-              PreferenceDivider()
-              Preference(
-                title = { Text(stringResource(R.string.pref_decoder)) },
-                summary = { Text(stringResource(R.string.pref_decoder_summary), color = MaterialTheme.colorScheme.outline) },
-                icon = { Icon(Icons.Default.DeveloperBoard, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
-                onClick = { backstack.add(DecoderPreferencesScreen) },
-              )
-              PreferenceDivider()
-              Preference(
-                title = { Text(stringResource(R.string.pref_audio)) },
-                summary = { Text(stringResource(R.string.pref_audio_summary), color = MaterialTheme.colorScheme.outline) },
-                icon = { Icon(Icons.Outlined.Audiotrack, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
-                onClick = { backstack.add(AudioPreferencesScreen) },
-              )
+          if (!enableExoPlayer) {
+            item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_playback)) }
+            item {
+              PreferenceCard {
+                Preference(
+                  title = { Text(stringResource(R.string.pref_player)) },
+                  summary = {
+                    Text(
+                      stringResource(R.string.pref_player_summary),
+                      color = MaterialTheme.colorScheme.outline
+                    )
+                  },
+                  icon = {
+                    Icon(
+                      Icons.Default.Slideshow,
+                      contentDescription = null,
+                      tint = MaterialTheme.colorScheme.primary
+                    )
+                  },
+                  onClick = { backstack.add(PlayerPreferencesScreen) },
+                )
+                PreferenceDivider()
+                Preference(
+                  title = { Text(stringResource(R.string.pref_decoder)) },
+                  summary = {
+                    Text(
+                      stringResource(R.string.pref_decoder_summary),
+                      color = MaterialTheme.colorScheme.outline
+                    )
+                  },
+                  icon = {
+                    Icon(
+                      Icons.Default.DeveloperBoard,
+                      contentDescription = null,
+                      tint = MaterialTheme.colorScheme.primary
+                    )
+                  },
+                  onClick = { backstack.add(DecoderPreferencesScreen) },
+                )
+                PreferenceDivider()
+                Preference(
+                  title = { Text(stringResource(R.string.pref_audio)) },
+                  summary = {
+                    Text(
+                      stringResource(R.string.pref_audio_summary),
+                      color = MaterialTheme.colorScheme.outline
+                    )
+                  },
+                  icon = {
+                    Icon(
+                      Icons.Outlined.Audiotrack,
+                      contentDescription = null,
+                      tint = MaterialTheme.colorScheme.primary
+                    )
+                  },
+                  onClick = { backstack.add(AudioPreferencesScreen) },
+                )
+              }
             }
           }
 
           // ── 3. Gestures & Controls ────────────────────────────────────────
-          item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_gestures_controls)) }
-          item {
-            PreferenceCard {
-              Preference(
-                title = { Text(stringResource(R.string.pref_gesture)) },
-                summary = { Text(stringResource(R.string.pref_gesture_summary), color = MaterialTheme.colorScheme.outline) },
-                icon = { Icon(Icons.Outlined.Gesture, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
-                onClick = { backstack.add(GesturePreferencesScreen) },
-              )
-              PreferenceDivider()
-              Preference(
-                title = { Text(stringResource(R.string.pref_layout_title)) },
-                summary = { Text(stringResource(R.string.pref_layout_summary), color = MaterialTheme.colorScheme.outline) },
-                icon = { Icon(Icons.Default.GridView, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
-                onClick = { backstack.add(PlayerControlsPreferencesScreen) },
-              )
+          if (!enableExoPlayer) {
+            item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_gestures_controls)) }
+            item {
+              PreferenceCard {
+                Preference(
+                  title = { Text(stringResource(R.string.pref_gesture)) },
+                  summary = {
+                    Text(
+                      stringResource(R.string.pref_gesture_summary),
+                      color = MaterialTheme.colorScheme.outline
+                    )
+                  },
+                  icon = {
+                    Icon(
+                      Icons.Outlined.Gesture,
+                      contentDescription = null,
+                      tint = MaterialTheme.colorScheme.primary
+                    )
+                  },
+                  onClick = { backstack.add(GesturePreferencesScreen) },
+                )
+                PreferenceDivider()
+                Preference(
+                  title = { Text(stringResource(R.string.pref_layout_title)) },
+                  summary = {
+                    Text(
+                      stringResource(R.string.pref_layout_summary),
+                      color = MaterialTheme.colorScheme.outline
+                    )
+                  },
+                  icon = {
+                    Icon(
+                      Icons.Default.GridView,
+                      contentDescription = null,
+                      tint = MaterialTheme.colorScheme.primary
+                    )
+                  },
+                  onClick = { backstack.add(PlayerControlsPreferencesScreen) },
+                )
+              }
             }
           }
 
           // ── 4. Subtitles ──────────────────────────────────────────────────
-          item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_subtitles)) }
-          item {
-            PreferenceCard {
-              Preference(
-                title = { Text(stringResource(R.string.pref_subtitles)) },
-                summary = { Text(stringResource(R.string.pref_subtitles_summary), color = MaterialTheme.colorScheme.outline) },
-                icon = { Icon(Icons.Outlined.Subtitles, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
-                onClick = { backstack.add(SubtitlesPreferencesScreen) },
-              )
+          if (!enableExoPlayer) {
+            item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_subtitles)) }
+            item {
+              PreferenceCard {
+                Preference(
+                  title = { Text(stringResource(R.string.pref_subtitles)) },
+                  summary = {
+                    Text(
+                      stringResource(R.string.pref_subtitles_summary),
+                      color = MaterialTheme.colorScheme.outline
+                    )
+                  },
+                  icon = {
+                    Icon(
+                      Icons.Outlined.Subtitles,
+                      contentDescription = null,
+                      tint = MaterialTheme.colorScheme.primary
+                    )
+                  },
+                  onClick = { backstack.add(SubtitlesPreferencesScreen) },
+                )
+              }
             }
           }
 
           // ── 5. Storage ────────────────────────────────────────────────────
-          item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_storage)) }
-          item {
-            PreferenceCard {
-              Preference(
-                title = { Text(stringResource(R.string.pref_folders_title)) },
-                summary = { Text(stringResource(R.string.pref_section_storage_summary), color = MaterialTheme.colorScheme.outline) },
-                icon = { Icon(Icons.Outlined.Folder, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
-                onClick = { backstack.add(FoldersPreferencesScreen) },
-              )
+          if (!enableExoPlayer) {
+            item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_storage)) }
+            item {
+              PreferenceCard {
+                Preference(
+                  title = { Text(stringResource(R.string.pref_folders_title)) },
+                  summary = {
+                    Text(
+                      stringResource(R.string.pref_section_storage_summary),
+                      color = MaterialTheme.colorScheme.outline
+                    )
+                  },
+                  icon = {
+                    Icon(
+                      Icons.Outlined.Folder,
+                      contentDescription = null,
+                      tint = MaterialTheme.colorScheme.primary
+                    )
+                  },
+                  onClick = { backstack.add(FoldersPreferencesScreen) },
+                )
+              }
             }
           }
 
           // ── 6. AI Integration ──────────────────────────────────────────────
-          item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_ai)) }
-          item {
-            PreferenceCard {
-              Preference(
-                title = { Text(stringResource(R.string.pref_section_ai_title)) },
-                summary = { Text(stringResource(R.string.pref_section_ai_summary), color = MaterialTheme.colorScheme.outline) },
-                icon = { Icon(Icons.Default.AutoAwesome, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
-                onClick = { backstack.add(AiIntegrationScreen) },
-              )
+          if (!enableExoPlayer) {
+            item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_ai)) }
+            item {
+              PreferenceCard {
+                Preference(
+                  title = { Text(stringResource(R.string.pref_section_ai_title)) },
+                  summary = {
+                    Text(
+                      stringResource(R.string.pref_section_ai_summary),
+                      color = MaterialTheme.colorScheme.outline
+                    )
+                  },
+                  icon = {
+                    Icon(
+                      Icons.Default.AutoAwesome,
+                      contentDescription = null,
+                      tint = MaterialTheme.colorScheme.primary
+                    )
+                  },
+                  onClick = { backstack.add(AiIntegrationScreen) },
+                )
+              }
             }
           }
 
           // ── 7. Advanced ───────────────────────────────────────────────────
-          item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_advanced)) }
+          if (!enableExoPlayer) {
+            item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_advanced)) }
+            item {
+              PreferenceCard {
+                Preference(
+                  title = { Text(stringResource(R.string.pref_advanced)) },
+                  summary = {
+                    Text(
+                      stringResource(R.string.pref_advanced_summary),
+                      color = MaterialTheme.colorScheme.outline
+                    )
+                  },
+                  icon = {
+                    Icon(
+                      Icons.Alternatives.AdvancedSettings,
+                      contentDescription = null,
+                      tint = MaterialTheme.colorScheme.primary
+                    )
+                  },
+                  onClick = { backstack.add(AdvancedPreferencesScreen) },
+                )
+              }
+            }
+          }
+
+          // ── 8. ExoPlayer ──────────────────────────────────────────────────
+          item { PreferenceSectionHeader(title = "ExoPlayer") }
           item {
             PreferenceCard {
-              Preference(
-                title = { Text(stringResource(R.string.pref_advanced)) },
-                summary = { Text(stringResource(R.string.pref_advanced_summary), color = MaterialTheme.colorScheme.outline) },
-                icon = { Icon(Icons.Alternatives.AdvancedSettings, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
-                onClick = { backstack.add(AdvancedPreferencesScreen) },
+              me.zhanghai.compose.preference.SwitchPreference(
+                value = enableExoPlayer,
+                onValueChange = { playerPreferences.enableExoPlayer.set(it) },
+                title = { Text("Enable ExoPlayer") },
+                summary = { Text("Use ExoPlayer as the video engine instead of mpv") },
+                icon = {
+                  Icon(
+                    Icons.Default.PlayCircle,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.primary
+                  )
+                },
               )
+
+              if (enableExoPlayer) {
+                // Ported settings from One-Player
+                Preference(
+                  title = { Text("Media Library") },
+                  summary = { Text("Ignore .nomedia, thumbnail generation", color = MaterialTheme.colorScheme.outline) },
+                  icon = { Icon(Icons.Default.Movie, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
+                  onClick = { backstack.add(ExoMediaLibraryPreferencesScreen) },
+                )
+                PreferenceDivider()
+                Preference(
+                  title = { Text("Player") },
+                  summary = { Text("Resume, speed, loop mode, orientation", color = MaterialTheme.colorScheme.outline) },
+                  icon = { Icon(Icons.Default.PlayArrow, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
+                  onClick = { backstack.add(ExoPlayerPreferencesScreen) },
+                )
+                PreferenceDivider()
+                Preference(
+                  title = { Text("Gestures") },
+                  summary = { Text("Double tap, seek, zoom, volume, brightness", color = MaterialTheme.colorScheme.outline) },
+                  icon = { Icon(Icons.Outlined.Gesture, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
+                  onClick = { backstack.add(ExoGesturePreferencesScreen) },
+                )
+                PreferenceDivider()
+                Preference(
+                  title = { Text("Video Processing") },
+                  summary = { Text("Decoder priority, video filters", color = MaterialTheme.colorScheme.outline) },
+                  icon = { Icon(Icons.Default.DeveloperBoard, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
+                  onClick = { backstack.add(ExoDecoderPreferencesScreen) },
+                )
+                PreferenceDivider()
+                Preference(
+                  title = { Text("Audio") },
+                  summary = { Text("Preferred languages, focus, volume memory", color = MaterialTheme.colorScheme.outline) },
+                  icon = { Icon(Icons.Default.Audiotrack, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
+                  onClick = { backstack.add(ExoAudioPreferencesScreen) },
+                )
+                PreferenceDivider()
+                Preference(
+                  title = { Text("Subtitle") },
+                  summary = { Text("Font, auto-load, encoding, appearance", color = MaterialTheme.colorScheme.outline) },
+                  icon = { Icon(Icons.Default.Subtitles, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
+                  onClick = { backstack.add(ExoSubtitlePreferencesScreen) },
+                )
+                PreferenceDivider()
+                Preference(
+                  title = { Text("General") },
+                  summary = { Text("Cache, backup, restore", color = MaterialTheme.colorScheme.outline) },
+                  icon = { Icon(Icons.Outlined.Settings, contentDescription = null, tint = MaterialTheme.colorScheme.primary) },
+                  onClick = { backstack.add(ExoGeneralPreferencesScreen) },
+                )
+              }
             }
           }
 
-          // ── 7. About ──────────────────────────────────────────────────────
+          // ── 9. About ──────────────────────────────────────────────────────
           item { PreferenceSectionHeader(title = stringResource(R.string.pref_section_about)) }
           item {
             PreferenceCard {
diff --git a/app/src/main/java/app/gyrolet/mpvrx/utils/media/MediaInfoOps.kt b/app/src/main/java/app/gyrolet/mpvrx/utils/media/MediaInfoOps.kt
index 721ac6515..a7ddc7ef7 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/utils/media/MediaInfoOps.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/utils/media/MediaInfoOps.kt
@@ -8,6 +8,14 @@ import kotlinx.coroutines.withContext
 import net.mediaarea.mediainfo.lib.MediaInfo
 
 object MediaInfoOps {
+  init {
+    try {
+        Class.forName("net.mediaarea.mediainfo.lib.MediaInfo")
+        android.util.Log.d("MediaInfoOps", "MediaInfo library found")
+    } catch (e: Throwable) {
+        android.util.Log.e("MediaInfoOps", "MediaInfo library NOT found or failed to load!", e)
+    }
+  }
   /**
    * Extract detailed media information from a video file
    */
@@ -420,6 +428,7 @@ object MediaInfoOps {
             retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_CAPTURE_FRAMERATE)
               ?.toFloatOrNull() ?: 0f,
           hasEmbeddedSubtitles = false,
+          subtitleCodec = "",
         )
       } finally {
         retriever.release()
@@ -462,4 +471,15 @@ object MediaInfoOps {
       }
     }.getOrDefault(0)
   }
+
+  /**
+   * Formats duration in milliseconds to a human-readable string (HH:MM:SS.mmm)
+   */
+  fun formatDuration(durationMs: Long): String {
+    val hours = durationMs / 3600000
+    val minutes = (durationMs % 3600000) / 60000
+    val seconds = (durationMs % 60000) / 1000
+    val millis = durationMs % 1000
+    return "%02d:%02d:%02d.%03d".format(hours, minutes, seconds, millis)
+  }
 }
diff --git a/app/src/main/java/app/gyrolet/mpvrx/utils/media/MediaUtils.kt b/app/src/main/java/app/gyrolet/mpvrx/utils/media/MediaUtils.kt
index d11c1db89..492a68a80 100644
--- a/app/src/main/java/app/gyrolet/mpvrx/utils/media/MediaUtils.kt
+++ b/app/src/main/java/app/gyrolet/mpvrx/utils/media/MediaUtils.kt
@@ -6,7 +6,10 @@ import android.net.Uri
 import androidx.core.content.FileProvider
 import androidx.core.net.toUri
 import app.gyrolet.mpvrx.domain.media.model.Video
+import app.gyrolet.mpvrx.exoplayer.ExoPlayerActivity
 import app.gyrolet.mpvrx.ui.player.PlayerActivity
+import app.gyrolet.mpvrx.preferences.PlayerPreferences
+import org.koin.java.KoinJavaComponent.inject
 import app.gyrolet.mpvrx.ui.player.PlayerLookupHints
 import app.gyrolet.mpvrx.utils.history.RecentlyPlayedOps
 import `is`.xyz.mpv.Utils
@@ -42,6 +45,15 @@ data class PlaybackSubtitleTrack(
  * bypassing MediaUtils.
  */
 object MediaUtils {
+  private val playerPreferences: PlayerPreferences by inject(PlayerPreferences::class.java)
+
+  private fun getPlayerActivityClass(): Class<*> {
+    return if (playerPreferences.enableExoPlayer.get()) {
+      ExoPlayerActivity::class.java
+    } else {
+      PlayerActivity::class.java
+    }
+  }
   /**
    * Play video content from any source.
    *
@@ -68,7 +80,7 @@ object MediaUtils {
       when (source) {
         is Video -> {
           val intent = Intent(Intent.ACTION_VIEW, source.uri)
-          intent.setClass(context, PlayerActivity::class.java)
+          intent.setClass(context, getPlayerActivityClass())
           intent.putExtra("internal_launch", true) // Enables subtitle autoload
           applyPlaybackExtras(
             intent = intent,
@@ -113,7 +125,7 @@ object MediaUtils {
       }
 
     val intent = Intent(Intent.ACTION_VIEW, uri)
-    intent.setClass(context, PlayerActivity::class.java)
+    intent.setClass(context, getPlayerActivityClass())
     intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
     intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
     applyPlaybackExtras(
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/ExoPlayerActivity.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/ExoPlayerActivity.kt
new file mode 100644
index 000000000..7c468806c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/ExoPlayerActivity.kt
@@ -0,0 +1,892 @@
+package app.gyrolet.mpvrx.exoplayer
+
+import android.annotation.SuppressLint
+import android.content.ComponentName
+import android.content.Intent
+import android.content.pm.ActivityInfo
+import android.graphics.Color
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.provider.MediaStore
+import android.view.KeyEvent
+import android.view.PixelCopy
+import android.view.SurfaceView
+import android.view.View
+import android.view.WindowManager
+import android.widget.Toast
+import androidx.activity.SystemBarStyle
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.activity.result.contract.ActivityResultContracts.RequestPermission
+import androidx.appcompat.app.AppCompatActivity
+import androidx.compose.runtime.getValue
+import org.koin.androidx.viewmodel.ext.android.viewModel
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.testTagsAsResourceId
+import androidx.core.content.ContextCompat
+import androidx.core.content.IntentCompat
+import androidx.core.graphics.createBitmap
+import androidx.core.util.Consumer
+import androidx.lifecycle.compose.LifecycleStartEffect
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Player
+import androidx.media3.session.MediaController
+import androidx.media3.session.SessionToken
+import com.google.common.util.concurrent.ListenableFuture
+import java.io.File
+import java.io.IOException
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.concurrent.CopyOnWriteArrayList
+import kotlin.coroutines.resume
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.guava.await
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.applyNavigationBarStyle
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.applyPrivacyProtection
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.canonicalPathOrSelf
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.getFilenameFromUri
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.getMediaContentUri
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.isSubtitleExtension
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.resolvePrivacyPreviewScrim
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.scanFileForContentUri
+import app.gyrolet.mpvrx.exoplayer.core.model.ScreenOrientation
+import app.gyrolet.mpvrx.exoplayer.core.model.Video
+import app.gyrolet.mpvrx.ui.theme.MpvrxTheme
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.OpenDocumentWithInitialUri
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.copy
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.registerForSuspendActivityResult
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.setMetadataExtras
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.OnlineSubtitleRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.InvalidOnlineSubtitleSchemeException
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.InvalidOnlineSubtitleUrlException
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.InvalidOnlineSubtitleExtensionException
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.OnlineSubtitleTooLargeException
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.EmptyOnlineSubtitleException
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.OnlineSubtitleDownloadFailedException
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.toActivityOrientation
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.uriToSubtitleConfiguration
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.addSubtitleTrack
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.stopPlayerSession
+import app.gyrolet.mpvrx.exoplayer.feature.player.MediaPlayerScreen
+import app.gyrolet.mpvrx.exoplayer.feature.player.PlayerViewModel
+import app.gyrolet.mpvrx.R
+import org.koin.android.ext.android.inject
+
+internal data class PlaybackPlaylist(
+    val items: List<String>,
+    val currentIndex: Int,
+)
+
+internal data class PlaybackTarget(
+    val sourceUriString: String,
+    val playbackUriString: String,
+    val currentPath: String?,
+)
+
+internal fun buildPlaybackPlaylistFromItems(
+    playlistItems: List<String>,
+    playbackTarget: PlaybackTarget,
+): PlaybackPlaylist {
+    if (playlistItems.isEmpty()) {
+        return PlaybackPlaylist(
+            items = listOf(playbackTarget.playbackUriString),
+            currentIndex = 0,
+        )
+    }
+
+    val currentIndex = playlistItems.indexOfFirst { uriString ->
+        uriString == playbackTarget.playbackUriString ||
+            uriString == playbackTarget.sourceUriString
+    }
+    if (currentIndex >= 0) {
+        return PlaybackPlaylist(
+            items = playlistItems,
+            currentIndex = currentIndex,
+        )
+    }
+
+    return PlaybackPlaylist(
+        items = listOf(playbackTarget.playbackUriString) + playlistItems,
+        currentIndex = 0,
+    )
+}
+
+internal fun buildPlaybackPlaylist(
+    playlistVideos: List<Video>,
+    playbackTarget: PlaybackTarget,
+): PlaybackPlaylist {
+    if (playlistVideos.isEmpty()) {
+        return PlaybackPlaylist(
+            items = listOf(playbackTarget.playbackUriString),
+            currentIndex = 0,
+        )
+    }
+
+    val currentIndex = playlistVideos.indexOfFirst { video ->
+        video.uriString == playbackTarget.playbackUriString ||
+            video.uriString == playbackTarget.sourceUriString ||
+            (playbackTarget.currentPath != null && video.path == playbackTarget.currentPath)
+    }
+    if (currentIndex >= 0) {
+        return PlaybackPlaylist(
+            items = playlistVideos.map { video -> video.uriString },
+            currentIndex = currentIndex,
+        )
+    }
+
+    return buildPlaybackPlaylistFromItems(
+        playlistItems = playlistVideos.map { video -> video.uriString },
+        playbackTarget = playbackTarget,
+    )
+}
+
+private val storagePermission = when {
+    Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU -> android.Manifest.permission.READ_MEDIA_VIDEO
+    else -> android.Manifest.permission.READ_EXTERNAL_STORAGE
+}
+
+@SuppressLint("UnsafeOptInUsageError")
+class ExoPlayerActivity : AppCompatActivity() {
+
+    companion object {
+        private const val TAG = "ExoPlayerActivity"
+
+        private val SUBTITLE_DOCUMENT_MIME_TYPES = arrayOf(
+            "application/octet-stream",
+            "application/ttml+xml",
+            "application/x-ass",
+            "application/x-subrip",
+            "application/x-ssa",
+            "audio/aac",
+            "text/*",
+            "text/plain",
+            "text/srt",
+            "text/vtt",
+            "text/x-ass",
+            "text/x-ssa",
+        )
+    }
+
+    val mediaSynchronizer: MediaSynchronizer by inject()
+    val onlineSubtitleRepository: OnlineSubtitleRepository by inject()
+
+    private val viewModel: PlayerViewModel by viewModel()
+    val playerPreferences get() = viewModel.uiState.value.playerPreferences
+
+    private val onWindowAttributesChangedListener = CopyOnWriteArrayList<Consumer<WindowManager.LayoutParams?>>()
+
+    private var isPlaybackFinished = false
+    private var shouldPlayInBackground: Boolean = false
+    private var isIntentNew: Boolean = true
+    private var keyboardEventHandler: ((KeyEvent) -> Boolean)? = null
+
+    private var controllerFuture: ListenableFuture<MediaController>? = null
+    private var mediaController: MediaController? = null
+    private var playerApi: PlayerApi? = null
+
+    private val playbackStateListener: Player.Listener = playbackStateListener()
+
+    private val subtitleFileSuspendLauncher = registerForSuspendActivityResult(OpenDocumentWithInitialUri())
+    private val mediaPermissionLauncher = registerForActivityResult(RequestPermission()) { isGranted ->
+        if (!isGranted) return@registerForActivityResult
+
+        lifecycleScope.launch {
+            maybeInitControllerFuture()
+            mediaController = controllerFuture?.await()
+            mediaController?.run {
+                updateKeepScreenOnFlag()
+                addListener(playbackStateListener)
+                startPlayback()
+            }
+        }
+    }
+
+    @OptIn(ExperimentalComposeUiApi::class)
+    override fun onCreate(savedInstanceState: Bundle?) {
+        try {
+            super.onCreate(savedInstanceState)
+            val initialUiState = viewModel.uiState.value
+            applyPrivacyProtection(
+                shouldPreventScreenshots = initialUiState.shouldPreventScreenshots,
+                shouldHideInRecents = initialUiState.shouldHideInRecents,
+            )
+            presetVideoOrientation()
+            val systemBarScrim = resolvePrivacyPreviewScrim(
+                shouldHideInRecents = initialUiState.shouldHideInRecents,
+            )
+            enableEdgeToEdge(
+                statusBarStyle = SystemBarStyle.dark(systemBarScrim),
+                navigationBarStyle = SystemBarStyle.dark(systemBarScrim),
+            )
+            applyNavigationBarStyle(color = Color.BLACK, shouldUseDarkIcons = false)
+
+            setContent {
+                val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+                var player by remember { mutableStateOf<MediaController?>(null) }
+                var isTakingScreenshot by remember { mutableStateOf(false) }
+
+                LifecycleStartEffect(
+                    uiState.shouldPreventScreenshots,
+                    uiState.shouldHideInRecents,
+                ) {
+                    this@ExoPlayerActivity.applyPrivacyProtection(
+                        shouldPreventScreenshots = uiState.shouldPreventScreenshots,
+                        shouldHideInRecents = uiState.shouldHideInRecents,
+                    )
+                    onStopOrDispose {}
+                }
+
+                LifecycleStartEffect(Unit) {
+                    maybeInitControllerFuture()
+                    lifecycleScope.launch {
+                        player = controllerFuture?.await()
+                    }
+
+                    onStopOrDispose {
+                        player = null
+                    }
+                }
+
+                MpvrxTheme {
+                    MediaPlayerScreen(
+                        modifier = Modifier.semantics {
+                            testTagsAsResourceId = true
+                        },
+                        player = player,
+                        viewModel = viewModel,
+                        playerPreferences = uiState.playerPreferences ?: return@MpvrxTheme,
+                        externalSubtitleFontSource = uiState.externalSubtitleFontSource,
+                        onSelectSubtitleClick = {
+                            lifecycleScope.launch {
+                                val uri = subtitleFileSuspendLauncher.launch(
+                                    OpenDocumentWithInitialUri.Input(
+                                        mimeTypes = SUBTITLE_DOCUMENT_MIME_TYPES,
+                                        initialUri = IntentCompat.getParcelableExtra(
+                                            intent,
+                                            "initial_subtitle_directory_uri",
+                                            Uri::class.java,
+                                        ),
+                                    ),
+                                ) ?: return@launch
+                                if (!isSupportedSubtitleDocument(uri)) {
+                                    showToast(R.string.local_subtitle_unsupported)
+                                    return@launch
+                                }
+                                contentResolver.takePersistableUriPermission(uri, Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                                maybeInitControllerFuture()
+                                controllerFuture?.await()?.addSubtitleTrack(uri)
+                            }
+                        },
+                        onAddOnlineSubtitleClick = ::addOnlineSubtitle,
+                        onBackClick = { finishAndStopPlayerSession() },
+                        onPlayInBackgroundClick = {
+                            shouldPlayInBackground = true
+                            finish()
+                        },
+                        isTakingScreenshot = isTakingScreenshot,
+                        onScreenshotClick = screenshotClick@{
+                            if (isTakingScreenshot) return@screenshotClick
+                            lifecycleScope.launch {
+                                isTakingScreenshot = true
+                                try {
+                                    val messageResId = runCatching {
+                                        if (saveCurrentFrameScreenshot()) {
+                                            R.string.screenshot_saved
+                                        } else {
+                                            R.string.screenshot_failed
+                                        }
+                                    }.getOrElse {
+                                        Logger.error(TAG, "Failed to take screenshot", it)
+                                        R.string.screenshot_failed
+                                    }
+                                    Toast.makeText(this@ExoPlayerActivity, messageResId, Toast.LENGTH_SHORT).show()
+                                } finally {
+                                    isTakingScreenshot = false
+                                }
+                            }
+                        },
+                        onKeyboardEventHandlerChanged = { handler ->
+                            keyboardEventHandler = handler
+                        },
+                    )
+                }
+            }
+
+            playerApi = PlayerApi(this)
+        } catch (e: Exception) {
+            android.util.Log.e(TAG, "ExoPlayerActivity onCreate failed!", e)
+            finish()
+        }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        lifecycleScope.launch(Dispatchers.IO) {
+            onlineSubtitleRepository.deleteExpiredSubtitles()
+        }
+        lifecycleScope.launch {
+            if (!ensureMediaPermission()) return@launch
+
+            maybeInitControllerFuture()
+            mediaController = controllerFuture?.await()
+
+            mediaController?.run {
+                updateKeepScreenOnFlag()
+                addListener(playbackStateListener)
+                startPlayback()
+            }
+        }
+    }
+
+    override fun onStop() {
+        keyboardEventHandler = null
+        mediaController?.run {
+            viewModel.shouldPlayWhenReady = playWhenReady
+            removeListener(playbackStateListener)
+        }
+        val shouldPlayInBackground = shouldPlayInBackground || playerPreferences?.shouldAutoPlayInBackground == true
+        if (subtitleFileSuspendLauncher.isAwaitingResult || !shouldPlayInBackground) {
+            mediaController?.pause()
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && isInPictureInPictureMode) {
+            finish()
+            if (!shouldPlayInBackground) {
+                mediaController?.stopPlayerSession()
+            }
+        }
+
+        controllerFuture?.run {
+            MediaController.releaseFuture(this)
+            controllerFuture = null
+        }
+        super.onStop()
+    }
+
+    override fun dispatchKeyEvent(event: KeyEvent): Boolean {
+        if (keyboardEventHandler?.invoke(event) == true) {
+            return true
+        }
+        return super.dispatchKeyEvent(event)
+    }
+
+    private fun maybeInitControllerFuture() {
+        if (controllerFuture == null) {
+            val sessionToken = SessionToken(applicationContext, ComponentName(applicationContext, ExoPlayerService::class.java))
+            controllerFuture = MediaController.Builder(applicationContext, sessionToken).buildAsync()
+        }
+    }
+
+    private fun addOnlineSubtitle(subtitleUrl: String) {
+        if (subtitleUrl.isBlank()) {
+            showToast(R.string.online_subtitle_empty)
+            return
+        }
+
+        lifecycleScope.launch {
+            Logger.debug(TAG, "Add online subtitle requested: ${subtitleUrl.toLogSummary()}")
+            val messageResId = try {
+                val downloadedSubtitle = withContext(Dispatchers.IO) {
+                    onlineSubtitleRepository.downloadSubtitle(subtitleUrl)
+                }
+                maybeInitControllerFuture()
+                val controller = controllerFuture?.await() ?: error("MediaController is unavailable")
+                controller.addSubtitleTrack(downloadedSubtitle.uri)
+                Logger.debug(TAG, "Add online subtitle command sent: uri=${downloadedSubtitle.uriString}")
+                R.string.online_subtitle_added
+            } catch (exception: CancellationException) {
+                throw exception
+            } catch (exception: InvalidOnlineSubtitleSchemeException) {
+                R.string.online_subtitle_unsupported_url
+            } catch (exception: InvalidOnlineSubtitleUrlException) {
+                R.string.online_subtitle_unsupported_url
+            } catch (exception: InvalidOnlineSubtitleExtensionException) {
+                R.string.online_subtitle_unsupported_url
+            } catch (exception: OnlineSubtitleTooLargeException) {
+                R.string.online_subtitle_too_large
+            } catch (exception: EmptyOnlineSubtitleException) {
+                R.string.online_subtitle_empty
+            } catch (exception: OnlineSubtitleDownloadFailedException) {
+                R.string.online_subtitle_download_failed
+            } catch (exception: Exception) {
+                Logger.error(TAG, "Failed to add online subtitle", exception)
+                R.string.online_subtitle_download_failed
+            }
+            showToast(messageResId)
+        }
+    }
+
+    private fun showToast(messageResId: Int) {
+        Toast.makeText(this@ExoPlayerActivity, messageResId, Toast.LENGTH_SHORT).show()
+    }
+
+    private fun isSupportedSubtitleDocument(uri: Uri): Boolean {
+        val fileName = getFilenameFromUri(uri)
+        val extension = fileName.substringAfterLast('.', missingDelimiterValue = "")
+        return extension.isSubtitleExtension()
+    }
+
+    private fun String.toLogSummary(): String {
+        val uri = Uri.parse(this)
+        val extension = uri.lastPathSegment?.substringAfterLast('.', missingDelimiterValue = "")?.lowercase().orEmpty()
+        return "scheme=${uri.scheme.orEmpty()} host=${uri.host.orEmpty()} extension=$extension"
+    }
+
+    private fun startPlayback() {
+        val uri = intent.data ?: return
+
+        val isReturningFromBackground = !isIntentNew && mediaController?.currentMediaItem != null
+        val isNewUriTheCurrentMediaItem = mediaController?.currentMediaItem?.localConfiguration?.uri.toString() == uri.toString()
+
+        if (isReturningFromBackground || isNewUriTheCurrentMediaItem) {
+            Logger.info(
+                TAG,
+                "startPlayback reused current item returning=$isReturningFromBackground same=$isNewUriTheCurrentMediaItem uri=$uri",
+            )
+            mediaController?.prepare()
+            mediaController?.playWhenReady = viewModel.shouldPlayWhenReady
+            return
+        }
+
+        isIntentNew = false
+
+        lifecycleScope.launch {
+            playVideo(uri)
+        }
+    }
+
+    private suspend fun playVideo(uri: Uri) = withContext(Dispatchers.Default) {
+        val t0 = System.currentTimeMillis()
+        Logger.info(TAG, "playVideo start uri=$uri")
+
+        val playbackUri = resolvePlaybackUri(uri)
+        val requestHeaders = buildRequestHeadersFromIntent()
+        if (uri.scheme == "file") {
+            uri.path?.let { path ->
+                mediaSynchronizer.registerManualVideoPath(path)
+                Logger.info(TAG, "playVideo registeredManualPath=$path")
+            }
+        }
+        val t1 = System.currentTimeMillis()
+        Logger.info(TAG, "playVideo resolveUri=${t1 - t0}ms resolved=$playbackUri")
+
+        val playbackTarget = PlaybackTarget(
+            sourceUriString = uri.toString(),
+            playbackUriString = playbackUri.toString(),
+            currentPath = playbackUri.path,
+        )
+        val currentMediaItem = buildMediaItem(
+            uriString = playbackUri.toString(),
+            requestHeaders = requestHeaders,
+            isCurrentItem = true,
+            localParentPath = null,
+        )
+
+        withContext(Dispatchers.Main) {
+            mediaController?.run {
+                setMediaItem(currentMediaItem, (playerApi?.position?.times(1000))?.toLong() ?: C.TIME_UNSET)
+                playWhenReady = viewModel.shouldPlayWhenReady
+                prepare()
+                Logger.info(TAG, "playVideo prepare total=${System.currentTimeMillis() - t0}ms")
+            }
+        }
+
+        appendPlaylistAfterCurrent(
+            currentMediaItem = currentMediaItem,
+            playbackTarget = playbackTarget,
+            requestHeaders = requestHeaders,
+            startedAtMs = t0,
+            playlistStartedAtMs = System.currentTimeMillis(),
+        )
+    }
+
+    private suspend fun appendPlaylistAfterCurrent(
+        currentMediaItem: MediaItem,
+        playbackTarget: PlaybackTarget,
+        requestHeaders: Map<String, String>,
+        startedAtMs: Long,
+        playlistStartedAtMs: Long,
+    ) = coroutineScope {
+        val apiPlaylist = playerApi?.getPlaylist().orEmpty()
+        val folderPlaylist = if (apiPlaylist.isEmpty()) {
+            viewModel.getPlaylistFromUri(Uri.parse(playbackTarget.playbackUriString))
+        } else {
+            emptyList()
+        }
+        val playbackPlaylist = if (apiPlaylist.isNotEmpty()) {
+            buildPlaybackPlaylistFromItems(
+                playlistItems = apiPlaylist,
+                playbackTarget = playbackTarget,
+            )
+        } else {
+            buildPlaybackPlaylist(
+                playlistVideos = folderPlaylist,
+                playbackTarget = playbackTarget,
+            )
+        }
+        val playlist = playbackPlaylist.items
+        Logger.info(TAG, "playVideo playlist=${System.currentTimeMillis() - playlistStartedAtMs}ms size=${playlist.size}")
+        if (playlist.size <= 1) return@coroutineScope
+
+        val currentIndex = playbackPlaylist.currentIndex
+        val currentLocalParentPath = findLocalParentPath(folderPlaylist, playbackTarget.playbackUriString)
+            ?: findLocalParentPath(folderPlaylist, playbackTarget.sourceUriString)
+        val beforeItems = playlist.take(currentIndex).map { uriString ->
+            async {
+                buildMediaItem(
+                    uriString = uriString,
+                    requestHeaders = requestHeaders,
+                    isCurrentItem = false,
+                    localParentPath = findLocalParentPath(folderPlaylist, uriString),
+                )
+            }
+        }.awaitAll()
+        val afterItems = playlist.drop(currentIndex + 1).map { uriString ->
+            async {
+                buildMediaItem(
+                    uriString = uriString,
+                    requestHeaders = requestHeaders,
+                    isCurrentItem = false,
+                    localParentPath = findLocalParentPath(folderPlaylist, uriString),
+                )
+            }
+        }.awaitAll()
+
+        withContext(Dispatchers.Main) {
+            mediaController?.run {
+                val currentItem = currentMediaItem
+                if (currentItem.localConfiguration?.uri.toString() != playbackTarget.playbackUriString) return@run
+                if (mediaItemCount != 1) return@run
+
+                if (currentLocalParentPath != null) {
+                    replaceMediaItem(
+                        currentMediaItemIndex,
+                        currentItem.copy(localParentPath = currentLocalParentPath),
+                    )
+                }
+                if (beforeItems.isNotEmpty()) addMediaItems(0, beforeItems)
+                if (afterItems.isNotEmpty()) addMediaItems(currentMediaItemIndex + 1, afterItems)
+                Logger.info(TAG, "playVideo appendPlaylist total=${System.currentTimeMillis() - startedAtMs}ms")
+            }
+        }
+    }
+
+    private suspend fun buildMediaItem(
+        uriString: String,
+        requestHeaders: Map<String, String>,
+        isCurrentItem: Boolean,
+        localParentPath: String?,
+    ): MediaItem = coroutineScope {
+        val builder = MediaItem.Builder()
+        builder.setUri(uriString)
+        builder.setMediaId(uriString)
+        val remoteServerId = requestHeaders["_remote_server_id"]?.toLongOrNull()
+        val remoteProtocol = requestHeaders["_remote_protocol"]
+        val hasRemoteMetadata = remoteServerId != null && remoteProtocol != null
+        if (isCurrentItem || hasRemoteMetadata) {
+            val filePath = if (isCurrentItem) {
+                requestHeaders["_remote_file_path"]
+            } else {
+                Uri.parse(uriString).path
+            }
+            builder.setMediaMetadata(
+                MediaMetadata.Builder().apply {
+                    if (isCurrentItem) setTitle(playerApi?.title)
+                    val remoteDirectoryPath = filePath
+                        ?.substringBeforeLast('/', missingDelimiterValue = "")
+                        ?.ifBlank { "/" }
+                    setMetadataExtras(
+                        positionMs = if (isCurrentItem) (playerApi?.position?.times(1000))?.toLong() else null,
+                        requestHeaders = requestHeaders,
+                        remoteServerId = remoteServerId,
+                        remoteFilePath = filePath,
+                        remoteProtocol = remoteProtocol,
+                        localParentPath = localParentPath,
+                        remoteDirectoryPath = remoteDirectoryPath,
+                    )
+                }.build(),
+            )
+        }
+        if (isCurrentItem) {
+            val apiSubs = playerApi?.getSubs().orEmpty().map { subtitle ->
+                async {
+                    uriToSubtitleConfiguration(
+                        uri = subtitle.uri,
+                        subtitleEncoding = playerPreferences?.subtitleTextEncoding ?: "",
+                        isSelected = subtitle.isSelected,
+                    )
+                }
+            }.awaitAll()
+            builder.setSubtitleConfigurations(apiSubs)
+        }
+        builder.build()
+    }
+
+    private fun findLocalParentPath(
+        folderPlaylist: List<Video>,
+        uriString: String,
+    ): String? {
+        val itemPath = Uri.parse(uriString).path
+        return folderPlaylist
+            .find { video -> video.uriString == uriString || video.path == itemPath }
+            ?.parentPath
+            ?.takeIf { it.isNotBlank() }
+    }
+
+    private fun ensureMediaPermission(): Boolean {
+        if (hasMediaReadPermission()) return true
+
+        mediaPermissionLauncher.launch(storagePermission)
+        return false
+    }
+
+    private suspend fun resolvePlaybackUri(uri: Uri): Uri {
+        val t0 = System.currentTimeMillis()
+
+        if (uri.scheme == "file") {
+            val rawPath = uri.path ?: return uri
+            val canonicalPath = rawPath.canonicalPathOrSelf()
+            Logger.info(TAG, "resolveUri canonical=${System.currentTimeMillis() - t0}ms path=$canonicalPath")
+
+            if (File(canonicalPath).exists()) {
+                Logger.info(TAG, "resolveUri fileFallback=${System.currentTimeMillis() - t0}ms")
+                return Uri.fromFile(File(canonicalPath))
+            }
+
+            if (hasMediaReadPermission()) {
+                scanFileForContentUri(path = canonicalPath, timeoutMs = 800L)?.let {
+                    Logger.info(TAG, "resolveUri scanFile=${System.currentTimeMillis() - t0}ms result=$it")
+                    return it
+                }
+                Logger.info(TAG, "resolveUri scanFileMiss=${System.currentTimeMillis() - t0}ms")
+            } else {
+                Logger.info(TAG, "resolveUri skipMediaStore noReadPermission=true")
+            }
+            return uri
+        }
+
+        if (hasMediaReadPermission()) {
+            getMediaContentUri(uri)?.let {
+                Logger.info(TAG, "resolveUri contentUri=${System.currentTimeMillis() - t0}ms")
+                return it
+            }
+        }
+
+        return uri
+    }
+
+    private fun buildRequestHeadersFromIntent(): Map<String, String> {
+        val headerBundle = intent.getBundleExtra("headers") ?: return emptyMap()
+        return buildMap {
+            for (key in headerBundle.keySet()) {
+                val value = headerBundle.getString(key).orEmpty()
+                if (value.isNotEmpty()) put(key, value)
+            }
+        }
+    }
+
+    private fun hasMediaReadPermission(): Boolean = ContextCompat.checkSelfPermission(this, storagePermission) == android.content.pm.PackageManager.PERMISSION_GRANTED
+
+    private fun playbackStateListener() = object : Player.Listener {
+        override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+            super.onMediaItemTransition(mediaItem, reason)
+            intent.data = mediaItem?.localConfiguration?.uri
+            updateKeepScreenOnFlag()
+        }
+
+        override fun onIsPlayingChanged(isPlaying: Boolean) {
+            super.onIsPlayingChanged(isPlaying)
+            updateKeepScreenOnFlag()
+        }
+
+        override fun onPlaybackStateChanged(playbackState: Int) {
+            super.onPlaybackStateChanged(playbackState)
+            when (playbackState) {
+                Player.STATE_ENDED -> {
+                    isPlaybackFinished = mediaController?.playbackState == Player.STATE_ENDED
+                    updateKeepScreenOnFlag()
+                    finishAndStopPlayerSession()
+                }
+
+                else -> {}
+            }
+        }
+
+        override fun onPlayWhenReadyChanged(shouldPlayWhenReady: Boolean, reason: Int) {
+            super.onPlayWhenReadyChanged(shouldPlayWhenReady, reason)
+
+            if (reason == Player.PLAY_WHEN_READY_CHANGE_REASON_END_OF_MEDIA_ITEM) {
+                if (mediaController?.repeatMode != Player.REPEAT_MODE_OFF) return
+                isPlaybackFinished = true
+                finishAndStopPlayerSession()
+            }
+        }
+    }
+
+    override fun finish() {
+        if (playerApi?.shouldReturnResult == true) {
+            val result = playerApi?.getResult(
+                isPlaybackFinished = isPlaybackFinished,
+                duration = mediaController?.duration ?: C.TIME_UNSET,
+                position = mediaController?.currentPosition ?: C.TIME_UNSET,
+            )
+            setResult(RESULT_OK, result)
+        }
+        super.finish()
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        if (intent.data != null) {
+            setIntent(intent)
+            isIntentNew = true
+            if (mediaController != null) {
+                startPlayback()
+            }
+        }
+    }
+
+    private fun updateKeepScreenOnFlag() {
+        if (mediaController?.currentMediaItem != null && !isPlaybackFinished) {
+            window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        } else {
+            window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        }
+    }
+
+    private suspend fun saveCurrentFrameScreenshot(): Boolean = withContext(Dispatchers.Main) {
+        val surfaceView = findPlayerSurfaceView() ?: return@withContext false
+        if (surfaceView.width <= 0 || surfaceView.height <= 0) return@withContext false
+
+        val bitmap = createBitmap(surfaceView.width, surfaceView.height)
+        val copyResult = suspendCancellableCoroutine<Int> { continuation ->
+            PixelCopy.request(surfaceView, bitmap, { result ->
+                continuation.resume(result)
+            }, Handler(mainLooper))
+        }
+        if (copyResult != PixelCopy.SUCCESS) return@withContext false
+
+        withContext(Dispatchers.IO) {
+            saveScreenshotBitmap(bitmap)
+        }
+    }
+
+    private fun findPlayerSurfaceView(): SurfaceView? {
+        val rootView = window.decorView.rootView ?: return null
+        return findSurfaceView(rootView)
+    }
+
+    private fun findSurfaceView(view: View): SurfaceView? {
+        if (view is SurfaceView) return view
+        val group = view as? android.view.ViewGroup ?: return null
+        for (index in 0 until group.childCount) {
+            findSurfaceView(group.getChildAt(index))?.let { return it }
+        }
+        return null
+    }
+
+    private fun saveScreenshotBitmap(bitmap: android.graphics.Bitmap): Boolean {
+        val fileName = buildScreenshotFileName()
+        val collection = MediaStore.Images.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY)
+        val contentValues = android.content.ContentValues().apply {
+            put(MediaStore.Images.Media.DISPLAY_NAME, fileName)
+            put(MediaStore.Images.Media.MIME_TYPE, "image/png")
+            put(MediaStore.Images.Media.RELATIVE_PATH, "${android.os.Environment.DIRECTORY_PICTURES}/Screenshots")
+            put(MediaStore.Images.Media.IS_PENDING, 1)
+        }
+
+        val uri = contentResolver.insert(collection, contentValues) ?: return false
+        return try {
+            contentResolver.openOutputStream(uri)?.use { stream ->
+                if (!bitmap.compress(android.graphics.Bitmap.CompressFormat.PNG, 100, stream)) {
+                    throw IOException("Failed to compress screenshot")
+                }
+            } ?: throw IOException("Failed to open screenshot output stream")
+
+            contentResolver.update(
+                uri,
+                android.content.ContentValues().apply {
+                    put(MediaStore.Images.Media.IS_PENDING, 0)
+                },
+                null,
+                null,
+            ) > 0
+        } catch (e: Exception) {
+            contentResolver.delete(uri, null, null)
+            Logger.error(TAG, "Failed to save screenshot", e)
+            false
+        }
+    }
+
+    private fun buildScreenshotFileName(): String {
+        val timestamp = SimpleDateFormat("yyyyMMdd-HHmmss", Locale.US).format(Date())
+        return "Screenshot-$timestamp.png"
+    }
+
+    private fun finishAndStopPlayerSession() {
+        finish()
+        mediaController?.stopPlayerSession()
+    }
+
+    override fun onWindowAttributesChanged(params: WindowManager.LayoutParams?) {
+        super.onWindowAttributesChanged(params)
+        for (listener in onWindowAttributesChangedListener) {
+            listener.accept(params)
+        }
+    }
+
+    fun addOnWindowAttributesChangedListener(listener: Consumer<WindowManager.LayoutParams?>) {
+        onWindowAttributesChangedListener.add(listener)
+    }
+
+    fun removeOnWindowAttributesChangedListener(listener: Consumer<WindowManager.LayoutParams?>) {
+        onWindowAttributesChangedListener.remove(listener)
+    }
+
+    private fun presetVideoOrientation() {
+        val prefs = playerPreferences ?: return
+        val rememberedOrientation = prefs.lastPlayerScreenOrientation
+            ?.takeIf { prefs.shouldRememberPlayerScreenOrientation }
+            ?.toActivityOrientation()
+        if (rememberedOrientation != null) {
+            requestedOrientation = rememberedOrientation
+            return
+        }
+        if (prefs.playerScreenOrientation != ScreenOrientation.VIDEO_ORIENTATION) return
+        val uri = intent.data ?: return
+        lifecycleScope.launch(Dispatchers.IO) {
+            val video = viewModel.getVideoByUri(uri.toString()) ?: return@launch
+            if (video.width <= 0 || video.height <= 0) return@launch
+            val orientation = if (video.height >= video.width) {
+                ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
+            } else {
+                ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+            }
+            withContext(Dispatchers.Main) {
+                if (requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
+                    requestedOrientation = orientation
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/MediaSynchronizer.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/MediaSynchronizer.kt
new file mode 100644
index 000000000..9f9a273fd
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/MediaSynchronizer.kt
@@ -0,0 +1,8 @@
+package app.gyrolet.mpvrx.exoplayer
+
+interface MediaSynchronizer {
+    suspend fun refresh(path: String? = null): Boolean
+    suspend fun registerManualVideoPath(path: String)
+    fun startSync()
+    fun stopSync()
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/PlayerApi.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/PlayerApi.kt
new file mode 100644
index 000000000..e251d03b0
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/PlayerApi.kt
@@ -0,0 +1,72 @@
+package app.gyrolet.mpvrx.exoplayer
+
+import android.content.Intent
+import android.net.Uri
+import androidx.media3.common.C
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.getParcelableUriArray
+import app.gyrolet.mpvrx.exoplayer.feature.player.model.Subtitle
+
+class PlayerApi(val activity: ExoPlayerActivity) {
+
+    private val extras = activity.intent.extras
+    val isApiAccess: Boolean get() = extras != null
+    val hasPosition: Boolean get() = extras?.containsKey(API_POSITION) == true
+    val hasTitle: Boolean get() = extras?.containsKey(API_TITLE) == true
+    val shouldReturnResult: Boolean get() = extras?.containsKey(API_RETURN_RESULT) == true
+    val position: Int? get() = if (hasPosition) extras?.getInt(API_POSITION) else null
+    val title: String? get() = if (hasTitle) extras?.getString(API_TITLE) else null
+
+    fun getSubs(): List<Subtitle> {
+        if (extras == null) return emptyList()
+        if (!extras.containsKey(API_SUBS)) return emptyList()
+
+        val subs = extras.getParcelableUriArray(API_SUBS) ?: return emptyList()
+        val subsName = extras.getStringArray(API_SUBS_NAME)
+
+        val subsEnable = extras.getParcelableUriArray(API_SUBS_ENABLE)
+        val defaultSub = if (!subsEnable.isNullOrEmpty()) subsEnable[0] else null
+
+        return subs.mapIndexed { index, subtitleUri ->
+            val subtitleName = subsName?.let { if (it.size > index) it[index] else null }
+            Subtitle(
+                name = subtitleName,
+                uri = subtitleUri,
+                isSelected = subtitleUri == defaultSub,
+            )
+        }
+    }
+
+    fun getPlaylist(): List<String> {
+        if (extras == null) return emptyList()
+        if (!extras.containsKey(API_PLAYLIST)) return emptyList()
+        val playlist = extras.getParcelableUriArray(API_PLAYLIST) ?: return emptyList()
+        return playlist.map(Uri::toString)
+    }
+
+    fun getResult(isPlaybackFinished: Boolean, duration: Long, position: Long): Intent = Intent(API_RESULT_INTENT).apply {
+        if (isPlaybackFinished) {
+            putExtra(API_END_BY, API_END_BY_COMPLETION)
+        } else {
+            putExtra(API_END_BY, API_END_BY_USER)
+            if (duration != C.TIME_UNSET) putExtra(API_DURATION, duration.toInt())
+            if (position != C.TIME_UNSET) putExtra(API_POSITION, position.toInt())
+        }
+    }
+
+    companion object {
+        const val API_TITLE = "title"
+        const val API_POSITION = "position"
+        const val API_DURATION = "duration"
+        const val API_RETURN_RESULT = "return_result"
+        const val API_END_BY = "end_by"
+        const val API_SUBS = "subs"
+        const val API_SUBS_ENABLE = "subs.enable"
+        const val API_SUBS_NAME = "subs.name"
+        const val API_PLAYLIST = "video_list"
+
+        const val API_RESULT_INTENT = "com.mxtech.intent.result.VIEW"
+
+        private const val API_END_BY_USER = "user"
+        private const val API_END_BY_COMPLETION = "playback_completion"
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/AppLanguageManager.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/AppLanguageManager.kt
new file mode 100644
index 000000000..c2cd40ef9
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/AppLanguageManager.kt
@@ -0,0 +1,34 @@
+package app.gyrolet.mpvrx.exoplayer.core.common
+
+import android.os.LocaleList
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.core.os.LocaleListCompat
+import java.util.Locale
+
+object AppLanguageManager {
+
+    fun applyToCurrent(languageTag: String) {
+        val normalizedLanguageTag = languageTag.trim()
+        val localeList = if (normalizedLanguageTag.isEmpty()) {
+            LocaleListCompat.getEmptyLocaleList()
+        } else {
+            LocaleListCompat.forLanguageTags(normalizedLanguageTag)
+        }
+
+        AppCompatDelegate.setApplicationLocales(localeList)
+        updateDefaultLocales(normalizedLanguageTag)
+    }
+
+    private fun updateDefaultLocales(languageTag: String) {
+        if (languageTag.isEmpty()) {
+            Locale.setDefault(Locale.getDefault())
+            LocaleList.setDefault(LocaleList.getAdjustedDefault())
+            return
+        }
+
+        val locale = Locale.forLanguageTag(languageTag)
+        Locale.setDefault(locale)
+        LocaleList.setDefault(LocaleList(locale))
+    }
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/FileLogStore.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/FileLogStore.kt
new file mode 100644
index 000000000..8fafcec92
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/FileLogStore.kt
@@ -0,0 +1,78 @@
+package app.gyrolet.mpvrx.exoplayer.core.common
+
+import android.content.Context
+import java.io.File
+import java.nio.charset.StandardCharsets
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+class FileLogStore(
+    context: Context,
+    private val maxSizeBytes: Long = MAX_LOG_SIZE_BYTES,
+) {
+    private val logFile = File(context.filesDir, LOG_FILE_NAME)
+    private val exportLogFile = File(context.cacheDir, EXPORT_LOG_FILE_NAME)
+    private val dateFormat = SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.US)
+    private val lock = Any()
+
+    fun append(
+        level: String,
+        tag: String,
+        message: String,
+        throwable: String? = null,
+    ) = synchronized(lock) {
+        val line = buildString {
+            append(dateFormat.format(Date()))
+            append(' ')
+            append(level)
+            append('/')
+            append(tag)
+            append(": ")
+            append(message)
+            throwable?.let {
+                appendLine()
+                append(it)
+            }
+            appendLine()
+        }
+
+        logFile.parentFile?.mkdirs()
+        logFile.appendText(line)
+        trimToMaxSize()
+    }
+
+    fun read(): String = synchronized(lock) {
+        if (!logFile.exists()) return@synchronized ""
+        logFile.readText()
+    }
+
+    fun clear() = synchronized(lock) {
+        if (logFile.exists()) logFile.writeText("")
+    }
+
+    fun exportFile(content: String): File = synchronized(lock) {
+        exportLogFile.parentFile?.mkdirs()
+        exportLogFile.writeText(content)
+        exportLogFile
+    }
+
+    private fun trimToMaxSize() {
+        if (logFile.length() <= maxSizeBytes) return
+
+        val bytes = logFile.readBytes()
+        val startIndex = (bytes.size - maxSizeBytes).coerceAtLeast(0).toInt()
+        val tail = bytes.copyOfRange(startIndex, bytes.size).toString(StandardCharsets.UTF_8)
+        val firstLineBreakIndex = tail.indexOf('\n')
+        logFile.writeText(
+            if (firstLineBreakIndex >= 0) tail.drop(firstLineBreakIndex + 1) else tail,
+        )
+    }
+
+    companion object {
+        private const val LOG_FILE_NAME = "only_player.log"
+        private const val EXPORT_LOG_FILE_NAME = "only_player_sanitized.log"
+        const val MAX_LOG_SIZE_BYTES = 10L * 1024L * 1024L
+    }
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/Logger.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/Logger.kt
new file mode 100644
index 000000000..168c8aaf6
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/Logger.kt
@@ -0,0 +1,76 @@
+package app.gyrolet.mpvrx.exoplayer.core.common
+
+import android.content.Context
+import android.util.Log
+
+object Logger {
+    private var fileLogStore: FileLogStore? = null
+
+    fun initialize(context: Context) {
+        fileLogStore = FileLogStore(context.applicationContext)
+    }
+
+    fun debug(tag: String, message: String) {
+        val sanitizedMessage = sanitize(message)
+        runCatching { Log.d("Logger - $tag", sanitizedMessage) }
+        writeToFile("D", tag, sanitizedMessage)
+    }
+
+    fun info(tag: String, message: String) {
+        val sanitizedMessage = sanitize(message)
+        runCatching { Log.i("Logger - $tag", sanitizedMessage) }
+        writeToFile("I", tag, sanitizedMessage)
+    }
+
+    fun error(tag: String, message: String, throwable: Throwable? = null) {
+        val sanitizedMessage = sanitize(message)
+        val sanitizedThrowable = throwable?.stackTraceToString()?.let(::sanitize)
+        val logcatMessage = buildString {
+            append(sanitizedMessage)
+            sanitizedThrowable?.let {
+                appendLine()
+                append(it)
+            }
+        }
+        runCatching { Log.e("Logger - $tag", logcatMessage) }
+        writeToFile("E", tag, sanitizedMessage, sanitizedThrowable)
+    }
+
+    fun readLogs(): String = runCatching { sanitize(fileLogStore?.read().orEmpty()) }.getOrDefault("")
+
+    fun clearLogs() {
+        runCatching { fileLogStore?.clear() }
+    }
+
+    fun exportFile() = runCatching { fileLogStore?.exportFile(readLogs()) }.getOrNull()
+
+    private fun writeToFile(
+        level: String,
+        tag: String,
+        message: String,
+        throwable: String? = null,
+    ) {
+        runCatching {
+            fileLogStore?.append(
+                level = level,
+                tag = tag,
+                message = message,
+                throwable = throwable,
+            )
+        }
+    }
+
+    private fun sanitize(text: String): String = text
+        .replace(URL_PATTERN, "<url>")
+        .replace(ANDROID_PATH_PATTERN, "<path>")
+        .replace(WINDOWS_PATH_PATTERN, "<path>")
+        .replace(EMAIL_PATTERN, "<email>")
+        .replace(IPV4_PATTERN, "<ip>")
+
+    private val URL_PATTERN = Regex("""(?i)\b(?:https?|file|content)://\S+""")
+    private val ANDROID_PATH_PATTERN = Regex("""(?<![\w.])/(?:storage|sdcard|data|mnt|system|vendor|product|apex|proc|dev|cache)(?:/[^\s)\]}>,;]*)*""")
+    private val WINDOWS_PATH_PATTERN = Regex("""(?i)\b[A-Z]:\\[^\s)\]}>,;]*""")
+    private val EMAIL_PATTERN = Regex("""\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b""", RegexOption.IGNORE_CASE)
+    private val IPV4_PATTERN = Regex("""\b(?:\d{1,3}\.){3}\d{1,3}\b""")
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/NextDispatchers.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/NextDispatchers.kt
new file mode 100644
index 000000000..3c68ab83a
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/NextDispatchers.kt
@@ -0,0 +1,9 @@
+package app.gyrolet.mpvrx.exoplayer.core.common
+
+annotation class Dispatcher(val niaDispatcher: NextDispatchers)
+
+enum class NextDispatchers {
+    Default,
+    IO,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/Utils.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/Utils.kt
new file mode 100644
index 000000000..f71af1ca9
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/Utils.kt
@@ -0,0 +1,94 @@
+package app.gyrolet.mpvrx.exoplayer.core.common
+
+import android.Manifest
+import android.content.Context
+import android.content.Intent
+import android.content.res.Resources
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.Settings
+import java.util.Locale
+import java.util.concurrent.TimeUnit
+import kotlin.math.abs
+
+val storagePermission = when {
+    Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU -> Manifest.permission.READ_MEDIA_VIDEO
+    else -> Manifest.permission.READ_EXTERNAL_STORAGE
+}
+
+fun hasManageExternalStorageAccess(): Boolean = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+    Environment.isExternalStorageManager()
+} else {
+    true
+}
+
+fun createManageExternalStorageAccessIntent(context: Context): Intent {
+    val manageAppIntent = Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION).apply {
+        data = Uri.parse("package:${context.packageName}")
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    }
+
+    return manageAppIntent.takeIf {
+        it.resolveActivity(context.packageManager) != null
+    } ?: Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    }
+}
+
+object Utils {
+
+    fun pxToDp(px: Float): Float = px / Resources.getSystem().displayMetrics.density
+
+    fun formatDurationMillis(millis: Long): String {
+        val hours = TimeUnit.MILLISECONDS.toHours(millis)
+        val minutes = TimeUnit.MILLISECONDS.toMinutes(millis) - TimeUnit.HOURS.toMinutes(hours)
+        val seconds = TimeUnit.MILLISECONDS.toSeconds(millis) -
+            TimeUnit.MINUTES.toSeconds(minutes) -
+            TimeUnit.HOURS.toSeconds(hours)
+        return if (hours > 0) {
+            String.format("%02d:%02d:%02d", hours, minutes, seconds)
+        } else {
+            String.format("%02d:%02d", minutes, seconds)
+        }
+    }
+
+    fun formatDurationMillisSign(millis: Long): String = if (millis >= 0) {
+        "+${formatDurationMillis(millis)}"
+    } else {
+        "-${formatDurationMillis(abs(millis))}"
+    }
+
+    fun formatFileSize(size: Long): String {
+        val kb = 1024
+        val mb = kb * 1024
+        val gb = mb * 1024
+
+        return when {
+            size < kb -> "$size B"
+            size < mb -> "%.2f KB".format(size / kb.toDouble())
+            size < gb -> "%.2f MB".format(size / mb.toDouble())
+            else -> "%.2f GB".format(size / gb.toDouble())
+        }
+    }
+
+    fun formatBitrate(bitrate: Long): String? {
+        if (bitrate <= 0) {
+            return null
+        }
+
+        val kiloBitrate = bitrate.toDouble() / 1000.0
+        val megaBitrate = kiloBitrate / 1000.0
+        val gigaBitrate = megaBitrate / 1000.0
+
+        return when {
+            gigaBitrate >= 1.0 -> String.format("%.1f Gbps", gigaBitrate)
+            megaBitrate >= 1.0 -> String.format("%.1f Mbps", megaBitrate)
+            kiloBitrate >= 1.0 -> String.format("%.1f kbps", kiloBitrate)
+            else -> String.format("%d bps", bitrate)
+        }
+    }
+
+    fun formatLanguage(language: String?): String? = language?.let { lang -> Locale.forLanguageTag(lang).displayLanguage.takeIf { it.isNotEmpty() } }
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Activity.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Activity.kt
new file mode 100644
index 000000000..4cbc8f2f4
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Activity.kt
@@ -0,0 +1,96 @@
+package app.gyrolet.mpvrx.exoplayer.core.common.extensions
+
+import android.app.Activity
+import android.app.ActivityManager
+import android.graphics.Color
+import android.os.Build
+import android.util.TypedValue
+import android.view.WindowManager
+import androidx.annotation.ColorInt
+import androidx.core.view.WindowCompat
+
+fun Activity.applyNavigationBarStyle(
+    @ColorInt color: Int,
+    shouldUseDarkIcons: Boolean,
+) {
+    if (window.navigationBarColor != color) {
+        window.navigationBarColor = color
+    }
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        if (window.isNavigationBarContrastEnforced) {
+            window.isNavigationBarContrastEnforced = false
+        }
+    }
+
+
+    val insetsController = WindowCompat.getInsetsController(window, window.decorView)
+    if (insetsController.isAppearanceLightNavigationBars != shouldUseDarkIcons) {
+        insetsController.isAppearanceLightNavigationBars = shouldUseDarkIcons
+    }
+}
+
+fun Activity.applyPrivacyProtection(
+    shouldPreventScreenshots: Boolean,
+    shouldHideInRecents: Boolean,
+) {
+    if (shouldPreventScreenshots) {
+        window.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
+    } else {
+        window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
+    }
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        setRecentsScreenshotEnabled(!shouldHideInRecents)
+    }
+
+    applyPrivacyTaskDescription(shouldHideInRecents = shouldHideInRecents)
+}
+
+@ColorInt
+fun Activity.resolvePrivacyPreviewColor(): Int {
+    val typedValue = TypedValue()
+    val isResolved = theme.resolveAttribute(android.R.attr.colorBackground, typedValue, true)
+    if (!isResolved) return Color.BLACK
+
+    return when {
+        typedValue.resourceId != 0 -> runCatching { getColor(typedValue.resourceId) }.getOrDefault(Color.BLACK)
+        typedValue.type in TypedValue.TYPE_FIRST_COLOR_INT..TypedValue.TYPE_LAST_COLOR_INT -> typedValue.data
+        else -> Color.BLACK
+    }
+}
+
+@ColorInt
+fun Activity.resolvePrivacyPreviewScrim(shouldHideInRecents: Boolean): Int = if (shouldHideInRecents) {
+    resolvePrivacyPreviewColor()
+} else {
+    Color.TRANSPARENT
+}
+
+private fun Activity.applyPrivacyTaskDescription(shouldHideInRecents: Boolean) {
+    val taskColor = if (shouldHideInRecents) {
+        resolvePrivacyPreviewColor()
+    } else {
+        null
+    }
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        val builder = ActivityManager.TaskDescription.Builder()
+        taskColor?.let { color ->
+            builder.setPrimaryColor(color)
+            builder.setBackgroundColor(color)
+            builder.setStatusBarColor(color)
+            builder.setNavigationBarColor(color)
+        }
+        setTaskDescription(builder.build())
+        return
+    }
+
+    @Suppress("DEPRECATION")
+    setTaskDescription(
+        ActivityManager.TaskDescription(
+            title?.toString(),
+            null,
+            taskColor ?: Color.BLACK,
+        ),
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Configuration.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Configuration.kt
new file mode 100644
index 000000000..da879d7c6
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Configuration.kt
@@ -0,0 +1,6 @@
+package app.gyrolet.mpvrx.exoplayer.core.common.extensions
+
+import android.content.res.Configuration
+
+val Configuration.isPortrait: Boolean
+    get() = orientation == Configuration.ORIENTATION_PORTRAIT
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Context.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Context.kt
new file mode 100644
index 000000000..23d7c8890
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Context.kt
@@ -0,0 +1,430 @@
+package app.gyrolet.mpvrx.exoplayer.core.common.extensions
+
+import android.app.UiModeManager
+import android.content.ContentResolver
+import android.content.ContentUris
+import android.content.ContentValues
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.content.res.Configuration
+import android.graphics.Bitmap
+import android.media.MediaScannerConnection
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.DocumentsContract
+import android.provider.MediaStore
+import android.provider.OpenableColumns
+import android.util.TypedValue
+import androidx.core.graphics.drawable.toBitmapOrNull
+import androidx.core.text.isDigitsOnly
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.InputStream
+import java.net.URL
+import java.nio.charset.Charset
+import java.nio.charset.StandardCharsets
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import org.mozilla.universalchardet.UniversalDetector
+
+val VIDEO_COLLECTION_URI: Uri
+    get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL)
+    } else {
+        MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+    }
+
+fun Context.getPath(uri: Uri): String? {
+    if (DocumentsContract.isDocumentUri(this, uri)) {
+        when {
+            uri.isExternalStorageDocument -> {
+                val docId = DocumentsContract.getDocumentId(uri)
+                val split = docId
+                    .split(":".toRegex())
+                    .dropLastWhile { it.isEmpty() }
+                    .toTypedArray()
+                if ("primary".equals(split[0], ignoreCase = true)) {
+                    return Environment.getExternalStorageDirectory().path + "/" + split[1]
+                }
+            }
+
+            uri.isDownloadsDocument -> {
+                val docId = DocumentsContract.getDocumentId(uri)
+                if (docId.isDigitsOnly()) {
+                    return try {
+                        val contentUri = ContentUris.withAppendedId(
+                            Uri.parse("content://downloads/public_downloads"),
+                            docId.toLong(),
+                        )
+                        getDataColumn(contentUri, null, null)
+                    } catch (e: Exception) {
+                        null
+                    }
+                }
+            }
+
+            uri.isMediaDocument -> {
+                val docId = DocumentsContract.getDocumentId(uri)
+                val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }
+                    .toTypedArray()
+                val contentUri = when (split[0]) {
+                    "image" -> MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+                    "video" -> MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+                    "audio" -> MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+                    else -> return null
+                }
+                return getDataColumn(contentUri, "_id=?", arrayOf(split[1]))
+            }
+        }
+        return null
+    }
+
+    if (ContentResolver.SCHEME_CONTENT.equals(uri.scheme, ignoreCase = true)) {
+        if (uri.isLocalPhotoPickerUri) return null
+        if (uri.isCloudPhotoPickerUri) return null
+        return if (uri.isGooglePhotosUri) uri.lastPathSegment else getDataColumn(uri, null, null)
+    }
+
+    if (ContentResolver.SCHEME_FILE.equals(uri.scheme, ignoreCase = true)) {
+        return uri.path
+    }
+
+    return null
+}
+
+private fun Context.getDataColumn(
+    uri: Uri,
+    selection: String? = null,
+    selectionArgs: Array<String>? = null,
+): String? {
+    val column = MediaStore.Images.Media.DATA
+    val projection = arrayOf(column)
+    try {
+        contentResolver.query(uri, projection, selection, selectionArgs, null)?.use { cursor ->
+            if (cursor.moveToFirst()) {
+                val index = cursor.getColumnIndexOrThrow(column)
+                return cursor.getString(index)
+            }
+        }
+    } catch (e: Exception) {
+        return null
+    }
+    return null
+}
+
+fun Context.getFilenameFromUri(uri: Uri): String = if (ContentResolver.SCHEME_FILE.equals(uri.scheme, ignoreCase = true)) {
+    File(uri.toString()).name
+} else {
+    getFilenameFromContentUri(uri) ?: uri.lastPathSegment ?: ""
+}
+
+fun Context.getFilenameFromContentUri(uri: Uri): String? {
+    val projection = arrayOf(
+        OpenableColumns.DISPLAY_NAME,
+    )
+
+    try {
+        val cursor = contentResolver.query(uri, projection, null, null, null)
+        cursor?.use {
+            if (cursor.moveToFirst()) {
+                return cursor.getString(cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME))
+            }
+        }
+    } catch (e: Exception) {
+        return null
+    }
+    return null
+}
+
+fun Context.getMediaContentUri(uri: Uri): Uri? {
+    val rawPath = getPath(uri) ?: return null
+    val path = rawPath.canonicalPathOrSelf()
+
+    val column = MediaStore.Video.Media._ID
+    val projection = arrayOf(column)
+    try {
+        contentResolver.query(
+            VIDEO_COLLECTION_URI,
+            projection,
+            "${MediaStore.Images.Media.DATA} = ?",
+            arrayOf(path),
+            null,
+        )?.use { cursor ->
+            if (cursor.moveToFirst()) {
+                val index = cursor.getColumnIndexOrThrow(column)
+                val id = cursor.getLong(index)
+                return ContentUris.withAppendedId(VIDEO_COLLECTION_URI, id)
+            }
+        }
+    } catch (e: Exception) {
+        return null
+    }
+    return null
+}
+
+fun Context.getMediaFileContentUri(path: String): Uri? {
+    val filesUri = MediaStore.Files.getContentUri(MediaStore.VOLUME_EXTERNAL)
+    val projection = arrayOf(MediaStore.Files.FileColumns._ID)
+
+    return try {
+        contentResolver.query(
+            filesUri,
+            projection,
+            "${MediaStore.Files.FileColumns.DATA} = ?",
+            arrayOf(path),
+            null,
+        )?.use { cursor ->
+            if (cursor.moveToFirst()) {
+                val index = cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns._ID)
+                ContentUris.withAppendedId(filesUri, cursor.getLong(index))
+            } else {
+                null
+            }
+        }
+    } catch (e: Exception) {
+        null
+    }
+}
+
+suspend fun Context.scanPaths(paths: List<String>): Boolean {
+    if (paths.isEmpty()) return true
+
+    return withTimeoutOrNull(15_000L) {
+        suspendCancellableCoroutine { continuation ->
+            try {
+                var remaining = paths.size
+                var hasSuccess = false
+                MediaScannerConnection.scanFile(
+                    this@scanPaths,
+                    paths.toTypedArray(),
+                    null,
+                ) { path, uri ->
+                    Logger.debug("ScanPath", "scanPaths: path=$path, uri=$uri")
+                    synchronized(paths) {
+                        if (uri != null) {
+                            hasSuccess = true
+                        }
+                        remaining--
+                        if (remaining == 0) {
+                            continuation.resumeWith(Result.success(hasSuccess))
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                continuation.resumeWith(Result.failure(e))
+            }
+        }
+    } ?: false
+}
+
+suspend fun Context.scanFileForContentUri(
+    path: String,
+    timeoutMs: Long = 3000L,
+): Uri? = withContext(Dispatchers.IO) {
+    try {
+        withTimeoutOrNull(timeoutMs) {
+            suspendCancellableCoroutine { continuation ->
+                MediaScannerConnection.scanFile(
+                    this@scanFileForContentUri,
+                    arrayOf(path),
+                    null,
+                ) { _, uri ->
+                    continuation.resumeWith(Result.success(uri))
+                }
+            }
+        }
+    } catch (_: Exception) {
+        null
+    }
+}
+
+suspend fun Context.scanStorage(
+    storagePath: String? = Environment.getExternalStorageDirectory()?.path,
+): Boolean = withContext(Dispatchers.IO) {
+    if (storagePath == null) return@withContext false
+
+    scanPaths(listOf(storagePath))
+}
+
+suspend fun Context.convertToUTF8(uri: Uri, charset: Charset? = null): Uri = withContext(Dispatchers.IO) {
+    try {
+        when {
+            uri.scheme?.let { it in listOf("http", "https", "ftp") } == true -> {
+                val url = URL(uri.toString())
+                val detectedCharset = charset ?: detectCharset(url)
+                if (detectedCharset == StandardCharsets.UTF_8) {
+                    uri
+                } else {
+                    convertNetworkUriToUTF8(url = url, sourceCharset = detectedCharset)
+                }
+            }
+
+            else -> {
+                val detectedCharset = charset ?: detectCharset(uri = uri, context = this@convertToUTF8)
+                if (detectedCharset == StandardCharsets.UTF_8) {
+                    uri
+                } else {
+                    convertLocalUriToUTF8(uri = uri, sourceCharset = detectedCharset)
+                }
+            }
+        }
+    } catch (exception: Exception) {
+        exception.printStackTrace()
+        uri
+    }
+}
+
+private fun detectCharset(uri: Uri, context: Context): Charset = context.contentResolver.openInputStream(uri)?.use { inputStream ->
+    detectCharsetFromStream(inputStream)
+} ?: StandardCharsets.UTF_8
+
+private fun detectCharset(url: URL): Charset = url.openStream().use { inputStream ->
+    detectCharsetFromStream(inputStream)
+}
+
+private fun detectCharsetFromStream(inputStream: InputStream): Charset {
+    return BufferedInputStream(inputStream).use { bufferedStream ->
+        val maxBytes = 1024 * 100 // 100 KB
+        val data = ByteArray(maxBytes)
+        val bytesRead = bufferedStream.read(data, 0, maxBytes)
+
+        if (bytesRead <= 0) {
+            return@use Charset.forName(StandardCharsets.UTF_8.name())
+        }
+
+        UniversalDetector(null).run {
+            handleData(data, 0, data.size)
+            dataEnd()
+            Charset.forName(detectedCharset ?: StandardCharsets.UTF_8.name())
+        }
+    }
+}
+
+private fun Context.convertLocalUriToUTF8(uri: Uri, sourceCharset: Charset): Uri {
+    val fileName = getFilenameFromUri(uri)
+    val file = File(subtitleCacheDir, fileName)
+
+    contentResolver.openInputStream(uri)?.use { inputStream ->
+        inputStream.reader(sourceCharset).buffered().use { reader ->
+            file.outputStream().writer(StandardCharsets.UTF_8).buffered().use { writer ->
+                reader.copyTo(writer)
+            }
+        }
+    }
+
+    return Uri.fromFile(file)
+}
+
+private fun Context.convertNetworkUriToUTF8(url: URL, sourceCharset: Charset): Uri {
+    val fileName = url.path.substringAfterLast('/')
+    val file = File(subtitleCacheDir, fileName)
+
+    url.openStream().use { inputStream ->
+        inputStream.reader(sourceCharset).buffered().use { reader ->
+            file.outputStream().writer(StandardCharsets.UTF_8).buffered().use { writer ->
+                reader.copyTo(writer)
+            }
+        }
+    }
+
+    return Uri.fromFile(file)
+}
+
+fun Context.isDeviceTvBox(): Boolean {
+    val uiModeManager = getSystemService(Context.UI_MODE_SERVICE) as UiModeManager
+    if (uiModeManager.currentModeType == Configuration.UI_MODE_TYPE_TELEVISION) return true
+    if (packageManager.hasSystemFeature("amazon.hardware.fire_tv")) return true
+    if (!hasStorageAccessFrameworkChooser()) return true
+
+    return false
+}
+
+fun Context.hasStorageAccessFrameworkChooser(): Boolean {
+    val intent = Intent(Intent.ACTION_OPEN_DOCUMENT)
+    intent.addCategory(Intent.CATEGORY_OPENABLE)
+    intent.type = "video/*"
+    return intent.resolveActivity(packageManager) != null
+}
+
+fun Context.pxToDp(px: Float) = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, px, resources.displayMetrics)
+
+fun Context.dpToPx(dp: Float) = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, resources.displayMetrics)
+
+val Context.subtitleCacheDir: File
+    get() {
+        val dir = File(cacheDir, "subtitles")
+        if (!dir.exists()) dir.mkdir()
+        return dir
+    }
+
+val Context.thumbnailCacheDir: File
+    get() {
+        val dir = File(cacheDir, "thumbnails")
+        if (!dir.exists()) dir.mkdir()
+        return dir
+    }
+
+val Context.externalSubtitleFontDir: File
+    get() {
+        val dir = File(filesDir, "subtitle-fonts")
+        if (!dir.exists()) dir.mkdirs()
+        return dir
+    }
+
+val Context.externalSubtitleFontFile: File
+    get() = File(externalSubtitleFontDir, "current.font")
+
+val Context.externalSubtitleFontTempFile: File
+    get() = File(externalSubtitleFontDir, "importing.font")
+
+val Context.externalSubtitleFontMetaFile: File
+    get() = File(externalSubtitleFontDir, "current.json")
+
+val Context.externalSubtitleFontTempMetaFile: File
+    get() = File(externalSubtitleFontDir, "importing.json")
+
+suspend fun ContentResolver.updateMedia(
+    uri: Uri,
+    contentValues: ContentValues,
+): Boolean = withContext(Dispatchers.IO) {
+    return@withContext try {
+        update(
+            uri,
+            contentValues,
+            null,
+            null,
+        ) > 0
+    } catch (e: Exception) {
+        e.printStackTrace()
+        false
+    }
+}
+
+suspend fun ContentResolver.deleteMedia(
+    uri: Uri,
+): Boolean = withContext(Dispatchers.IO) {
+    return@withContext try {
+        delete(uri, null, null) > 0
+    } catch (e: Exception) {
+        e.printStackTrace()
+        false
+    }
+}
+
+fun Context.getStorageVolumes() = try {
+    getExternalFilesDirs(null)?.mapNotNull {
+        File(it.path.substringBefore("/Android")).takeIf { file -> file.exists() }
+    } ?: listOf(Environment.getExternalStorageDirectory())
+} catch (e: Exception) {
+    listOf(Environment.getExternalStorageDirectory())
+}
+
+fun Context.appIcon(): Bitmap? = packageManager.getApplicationInfo(packageName, 0).loadIcon(packageManager)?.toBitmapOrNull()
+
+val Context.isPipFeatureSupported: Boolean
+    get() = packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/File.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/File.kt
new file mode 100644
index 000000000..ad288670b
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/File.kt
@@ -0,0 +1,108 @@
+package app.gyrolet.mpvrx.exoplayer.core.common.extensions
+
+import android.content.ContentResolver
+import android.content.Context
+import android.net.Uri
+import android.os.Environment
+import androidx.core.net.toUri
+import java.io.File
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+
+suspend fun File.getSubtitles(): List<File> = withContext(Dispatchers.IO) {
+    val mediaName = this@getSubtitles.nameWithoutExtension
+    val parentDir = this@getSubtitles.parentFile ?: return@withContext emptyList()
+
+    parentDir.listFiles()
+        ?.filter { it.isFile }
+        ?.filter { it.isSubtitle() }
+        ?.filter { it.name.matchesSubtitleBase(mediaName) }
+        .orEmpty()
+}
+
+suspend fun File.getLocalSubtitles(
+    context: Context,
+    excludeSubsList: List<Uri> = emptyList(),
+): List<Uri> = withContext(Dispatchers.IO) {
+    val excludeSubsPathSet = excludeSubsList.mapNotNull { subtitleUri ->
+        subtitleUri.toCanonicalLocalPath(context)
+    }.toSet()
+
+    getSubtitles().mapNotNull { file ->
+        val canonicalPath = file.path.canonicalPathOrSelf()
+        if (canonicalPath !in excludeSubsPathSet) {
+            File(canonicalPath).toUri()
+        } else {
+            null
+        }
+    }
+}
+
+fun String.getThumbnail(): File? {
+    val filePathWithoutExtension = this.substringBeforeLast(".")
+    val imageExtensions = listOf("png", "jpg", "jpeg")
+    for (imageExtension in imageExtensions) {
+        val file = File("$filePathWithoutExtension.$imageExtension")
+        if (file.exists()) return file
+    }
+    return null
+}
+
+fun File.isSubtitle(): Boolean = extension.isSubtitleExtension()
+
+fun String.isSubtitleExtension(): Boolean = lowercase() in SUBTITLE_EXTENSIONS
+
+fun String.matchesSubtitleBase(videoName: String): Boolean {
+    val subtitleBase = substringBeforeLast('.', missingDelimiterValue = this)
+    return subtitleBase.equals(videoName, ignoreCase = true) || subtitleBase.startsWith("$videoName.", ignoreCase = true)
+}
+
+fun File.deleteFiles() {
+    try {
+        listFiles()?.onEach {
+            it.delete()
+        }
+    } catch (e: Exception) {
+        Logger.error("File", "Failed to delete files", e)
+    }
+}
+
+fun String.canonicalPathOrSelf(): String = runCatching {
+    File(this).canonicalPath
+}.getOrDefault(this)
+
+fun Uri.toCanonicalLocalPath(context: Context): String? {
+    val rawPath = when (scheme) {
+        ContentResolver.SCHEME_FILE -> path
+        else -> context.getPath(this)
+    } ?: return null
+    return rawPath.canonicalPathOrSelf()
+}
+
+fun Uri.toCanonicalFilePathOrNull(): String? {
+    if (scheme != ContentResolver.SCHEME_FILE) return null
+    return path?.canonicalPathOrSelf()
+}
+
+fun String.isInsideNoMediaDirectory(): Boolean = File(this).isInsideNoMediaDirectory()
+
+fun File.isInsideNoMediaDirectory(): Boolean {
+    var currentDirectory = parentFile
+    while (currentDirectory != null && currentDirectory.exists()) {
+        if (File(currentDirectory, ".nomedia").exists()) {
+            return true
+        }
+        currentDirectory = currentDirectory.parentFile
+    }
+    return false
+}
+
+fun Iterable<String>.excludeNoMediaPaths(): List<String> = filterNot { path ->
+    path.isInsideNoMediaDirectory()
+}
+
+val File.prettyName: String
+    get() = this.name.takeIf { this.path != Environment.getExternalStorageDirectory()?.path } ?: "Internal Storage"
+
+private val SUBTITLE_EXTENSIONS = setOf("srt", "ssa", "ass", "vtt", "ttml")
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Float.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Float.kt
new file mode 100644
index 000000000..ebf243a79
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Float.kt
@@ -0,0 +1,9 @@
+package app.gyrolet.mpvrx.exoplayer.core.common.extensions
+
+import kotlin.math.pow
+import kotlin.math.roundToInt
+
+fun Float.round(decimalPlaces: Int): Float = (this * 10.0.pow(decimalPlaces.toDouble()))
+    .roundToInt() / 10.0.pow(decimalPlaces.toDouble()).toFloat()
+
+fun Float.toString(decimalPlaces: Int): String = "%.${decimalPlaces}f".format(this)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Uri.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Uri.kt
new file mode 100644
index 000000000..d7f74f79c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/common/extensions/Uri.kt
@@ -0,0 +1,21 @@
+package app.gyrolet.mpvrx.exoplayer.core.common.extensions
+
+import android.net.Uri
+
+val Uri.isExternalStorageDocument: Boolean
+    get() = "com.android.externalstorage.documents" == authority
+
+val Uri.isDownloadsDocument: Boolean
+    get() = "com.android.providers.downloads.documents" == authority
+
+val Uri.isMediaDocument: Boolean
+    get() = "com.android.providers.media.documents" == authority
+
+val Uri.isGooglePhotosUri: Boolean
+    get() = "com.google.android.apps.photos.content" == authority
+
+val Uri.isLocalPhotoPickerUri: Boolean
+    get() = toString().contains("com.android.providers.media.photopicker")
+
+val Uri.isCloudPhotoPickerUri: Boolean
+    get() = toString().contains("com.google.android.apps.photos.cloudpicker")
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/model/ExternalSubtitleFontMeta.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/model/ExternalSubtitleFontMeta.kt
new file mode 100644
index 000000000..df70a6448
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/model/ExternalSubtitleFontMeta.kt
@@ -0,0 +1,5 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.model
+
+data class ExternalSubtitleFontMeta(
+    val displayName: String,
+)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/models/RemotePlaybackInfo.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/models/RemotePlaybackInfo.kt
new file mode 100644
index 000000000..8d9f2d7bb
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/models/RemotePlaybackInfo.kt
@@ -0,0 +1,6 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.models
+
+data class RemotePlaybackInfo(
+    val playbackPosition: Long,
+    val lastPlayedTime: Long?,
+)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/models/VideoState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/models/VideoState.kt
new file mode 100644
index 000000000..02188f7ae
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/models/VideoState.kt
@@ -0,0 +1,15 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.models
+
+import android.net.Uri
+
+data class VideoState(
+    val path: String,
+    val position: Long?,
+    val audioTrackIndex: Int?,
+    val subtitleTrackIndex: Int?,
+    val playbackSpeed: Float?,
+    val externalSubs: List<Uri>,
+    val videoScale: Float,
+    val subtitleDelayMilliseconds: Long,
+    val subtitleSpeed: Float,
+)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/FolderPlaybackAnchorKey.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/FolderPlaybackAnchorKey.kt
new file mode 100644
index 000000000..00eb6f48e
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/FolderPlaybackAnchorKey.kt
@@ -0,0 +1,28 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import android.net.Uri
+
+private const val REMOTE_FOLDER_PLAYBACK_ANCHOR_PREFIX = "mpvrx://folder"
+private val SUPPORTED_REMOTE_PROTOCOLS = setOf("webdav", "ftp")
+
+fun buildRemoteFolderPlaybackAnchorKey(
+    remoteProtocol: String?,
+    remoteServerId: Long?,
+    directoryPath: String?,
+): String? {
+    val protocol = remoteProtocol?.lowercase()?.takeIf { it in SUPPORTED_REMOTE_PROTOCOLS } ?: return null
+    val serverId = remoteServerId?.takeIf { it > 0L } ?: return null
+    val normalizedPath = directoryPath?.normalizeFolderPlaybackAnchorPath() ?: return null
+    return "$REMOTE_FOLDER_PLAYBACK_ANCHOR_PREFIX/$protocol/$serverId$normalizedPath"
+}
+
+fun String.normalizeFolderPlaybackAnchorPath(): String? {
+    val raw = trim()
+    if (raw.isBlank()) return null
+    val decoded = runCatching { Uri.decode(raw) }.getOrDefault(raw)
+    val normalized = decoded
+        .replace(Regex("/+"), "/")
+        .removeSuffix("/")
+        .ifBlank { "/" }
+    return if (normalized.startsWith('/')) normalized else "/$normalized"
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalMediaRepositoryImpl.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalMediaRepositoryImpl.kt
new file mode 100644
index 000000000..26984cf1c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalMediaRepositoryImpl.kt
@@ -0,0 +1,227 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import android.content.Context
+import android.net.Uri
+import androidx.core.net.toUri
+import app.gyrolet.mpvrx.database.entities.PlaybackStateEntity
+import app.gyrolet.mpvrx.domain.playbackstate.repository.PlaybackStateRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.models.RemotePlaybackInfo
+import app.gyrolet.mpvrx.exoplayer.core.data.models.VideoState
+import app.gyrolet.mpvrx.exoplayer.core.model.Folder
+import app.gyrolet.mpvrx.exoplayer.core.model.Video
+import app.gyrolet.mpvrx.repository.MediaFileRepository
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import java.io.File
+
+class LocalMediaRepositoryImpl(
+    private val context: Context,
+    private val playbackStateRepository: PlaybackStateRepository,
+) : MediaRepository {
+
+    override fun getVideosFlow(): Flow<List<Video>> = flow {
+        // Implementation for listing all videos if needed for ExoPlayer specific screens
+        emit(emptyList())
+    }
+
+    override fun getVideosFlowFromFolderPath(folderPath: String): Flow<List<Video>> = flow {
+        val mpvVideos = runCatching { MediaFileRepository.getVideosInFolder(context, folderPath) }.getOrElse { emptyList() }
+        emit(mpvVideos.map { it.toExoVideo() })
+    }
+
+    override fun getRecycleBinVideosFlow(): Flow<List<Video>> = flow {
+        emit(emptyList())
+    }
+
+    override fun getFoldersFlow(): Flow<List<Folder>> = flow {
+        emit(emptyList())
+    }
+
+    override suspend fun getVideoByUri(uri: String): Video? {
+        // This is tricky because MpvRx doesn't have a direct "getVideoByUri" for any URI
+        // But we can try to resolve it if it's a file
+        val parsedUri = Uri.parse(uri)
+        if (parsedUri.scheme == "file") {
+            val file = File(parsedUri.path ?: return null)
+            if (file.exists()) {
+                // We'd need to scan it or have it in cache
+                return Video(
+                    id = uri.hashCode().toLong(),
+                    path = file.absolutePath,
+                    parentPath = file.parent ?: "",
+                    duration = 0,
+                    uriString = uri,
+                    nameWithExtension = file.name,
+                    width = 0,
+                    height = 0,
+                    size = file.length()
+                )
+            }
+        }
+        return null
+    }
+
+    override suspend fun getVideoState(uri: String): VideoState? {
+        val mediaTitle = getMediaTitleFromUri(uri)
+        val state = playbackStateRepository.getVideoDataByTitle(mediaTitle) ?: return null
+        return state.toExoVideoState(uri)
+    }
+
+    override suspend fun getVideoState(uris: List<String>): VideoState? {
+        for (uri in uris) {
+            val state = getVideoState(uri)
+            if (state != null) return state
+        }
+        return null
+    }
+
+    override suspend fun getCanonicalMediaUri(uri: String): String = uri
+
+    override suspend fun getRemotePlaybackStates(stateKeys: List<String>): Map<String, RemotePlaybackInfo> {
+        return emptyMap()
+    }
+
+    override suspend fun updateMediumLastPlayedTime(uri: String, lastPlayedTime: Long) {
+        // MpvRx doesn't track last played time per video in PlaybackStateEntity yet, 
+        // but it does in RecentlyPlayedEntity. 
+        // For simplicity, we can ignore this or add a column to PlaybackStateEntity.
+    }
+
+    override suspend fun updateMediumPosition(uri: String, position: Long) {
+        val mediaTitle = getMediaTitleFromUri(uri)
+        val existing = playbackStateRepository.getVideoDataByTitle(mediaTitle)
+        val entity = existing?.copy(
+            lastPosition = (position / 1000).toInt()
+        ) ?: PlaybackStateEntity(
+            mediaTitle = mediaTitle,
+            lastPosition = (position / 1000).toInt(),
+            playbackSpeed = 1.0,
+            sid = -1,
+            subDelay = 0,
+            subSpeed = 1.0,
+            aid = -1,
+            audioDelay = 0
+        )
+        playbackStateRepository.upsert(entity)
+    }
+
+    override suspend fun updateMediumPlaybackSpeed(uri: String, playbackSpeed: Float) {
+        val mediaTitle = getMediaTitleFromUri(uri)
+        val existing = playbackStateRepository.getVideoDataByTitle(mediaTitle)
+        if (existing != null) {
+            playbackStateRepository.upsert(existing.copy(playbackSpeed = playbackSpeed.toDouble()))
+        }
+    }
+
+    override suspend fun updateMediumAudioTrack(uri: String, audioTrackIndex: Int) {
+        val mediaTitle = getMediaTitleFromUri(uri)
+        val existing = playbackStateRepository.getVideoDataByTitle(mediaTitle)
+        if (existing != null) {
+            playbackStateRepository.upsert(existing.copy(aid = audioTrackIndex))
+        }
+    }
+
+    override suspend fun updateMediumSubtitleTrack(uri: String, subtitleTrackIndex: Int) {
+        val mediaTitle = getMediaTitleFromUri(uri)
+        val existing = playbackStateRepository.getVideoDataByTitle(mediaTitle)
+        if (existing != null) {
+            playbackStateRepository.upsert(existing.copy(sid = subtitleTrackIndex))
+        }
+    }
+
+    override suspend fun updateMediumZoom(uri: String, zoom: Float) {
+        val mediaTitle = getMediaTitleFromUri(uri)
+        val existing = playbackStateRepository.getVideoDataByTitle(mediaTitle)
+        if (existing != null) {
+            playbackStateRepository.upsert(existing.copy(videoZoom = zoom))
+        }
+    }
+
+    override suspend fun addExternalSubtitleToMedium(uri: String, subtitleUri: Uri) {
+        val mediaTitle = getMediaTitleFromUri(uri)
+        val existing = playbackStateRepository.getVideoDataByTitle(mediaTitle)
+        if (existing != null) {
+            val subs = if (existing.externalSubtitles.isBlank()) {
+                subtitleUri.toString()
+            } else {
+                existing.externalSubtitles + "," + subtitleUri.toString()
+            }
+            playbackStateRepository.upsert(existing.copy(externalSubtitles = subs))
+        }
+    }
+
+    override suspend fun updateExternalSubs(uri: String, externalSubs: List<Uri>) {
+        val mediaTitle = getMediaTitleFromUri(uri)
+        val existing = playbackStateRepository.getVideoDataByTitle(mediaTitle)
+        if (existing != null) {
+            playbackStateRepository.upsert(existing.copy(externalSubtitles = externalSubs.joinToString(",") { it.toString() }))
+        }
+    }
+
+    override suspend fun updateSubtitleDelay(uri: String, delay: Long) {
+        val mediaTitle = getMediaTitleFromUri(uri)
+        val existing = playbackStateRepository.getVideoDataByTitle(mediaTitle)
+        if (existing != null) {
+            playbackStateRepository.upsert(existing.copy(subDelay = delay.toInt()))
+        }
+    }
+
+    override suspend fun updateSubtitleSpeed(uri: String, speed: Float) {
+        val mediaTitle = getMediaTitleFromUri(uri)
+        val existing = playbackStateRepository.getVideoDataByTitle(mediaTitle)
+        if (existing != null) {
+            playbackStateRepository.upsert(existing.copy(subSpeed = speed.toDouble()))
+        }
+    }
+
+    override suspend fun moveVideosToRecycleBin(uris: List<String>) {}
+
+    override suspend fun moveVideosToFolder(
+        uris: List<String>,
+        targetFolderPath: String,
+        shouldCancel: () -> Boolean,
+        onProgress: (Int) -> Unit
+    ): MediaMoveSummary = MediaMoveSummary()
+
+    override suspend fun moveFoldersToFolder(
+        folderPaths: List<String>,
+        targetFolderPath: String,
+        shouldCancel: () -> Boolean,
+        onProgress: (Int) -> Unit
+    ): MediaMoveSummary = MediaMoveSummary()
+
+    override suspend fun restoreVideosFromRecycleBin(uris: List<String>) {}
+
+    private fun getMediaTitleFromUri(uriString: String): String {
+        val uri = Uri.parse(uriString)
+        return uri.lastPathSegment ?: uriString
+    }
+
+    private fun app.gyrolet.mpvrx.domain.media.model.Video.toExoVideo(): Video {
+        return Video(
+            id = this.id,
+            path = this.path,
+            parentPath = File(this.path).parent ?: "",
+            duration = this.duration,
+            uriString = this.uri.toString(),
+            nameWithExtension = this.displayName,
+            width = this.width,
+            height = this.height,
+            size = this.size
+        )
+    }
+
+    private fun PlaybackStateEntity.toExoVideoState(uri: String): VideoState {
+        return VideoState(
+            path = uri,
+            position = this.lastPosition * 1000L,
+            audioTrackIndex = if (this.aid >= 0) this.aid else null,
+            subtitleTrackIndex = if (this.sid >= 0) this.sid else null,
+            playbackSpeed = this.playbackSpeed.toFloat(),
+            externalSubs = if (this.externalSubtitles.isBlank()) emptyList() else this.externalSubtitles.split(",").map { it.toUri() },
+            videoScale = this.videoZoom,
+            subtitleDelayMilliseconds = this.subDelay.toLong(),
+            subtitleSpeed = this.subSpeed.toFloat()
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalPreferencesRepository.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalPreferencesRepository.kt
new file mode 100644
index 000000000..cbee3b194
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalPreferencesRepository.kt
@@ -0,0 +1,100 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.excludeNoMediaPaths
+import app.gyrolet.mpvrx.exoplayer.core.common.hasManageExternalStorageAccess
+import app.gyrolet.mpvrx.exoplayer.core.datastore.datasource.AppPreferencesDataSource
+import app.gyrolet.mpvrx.exoplayer.core.datastore.datasource.PlayerPreferencesDataSource
+import app.gyrolet.mpvrx.exoplayer.core.model.ApplicationPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.SettingsBackup
+
+class LocalPreferencesRepository(
+    private val appPreferencesDataSource: AppPreferencesDataSource,
+    private val playerPreferencesDataSource: PlayerPreferencesDataSource,
+    private val applicationScope: CoroutineScope,
+) : PreferencesRepository {
+
+    override val applicationPreferences: StateFlow<ApplicationPreferences> =
+        appPreferencesDataSource.preferences
+            .map(::sanitizeApplicationPreferences)
+            .stateIn(
+                scope = applicationScope,
+                started = SharingStarted.Eagerly,
+                initialValue = ApplicationPreferences(),
+            )
+
+    override val playerPreferences: StateFlow<PlayerPreferences> =
+        playerPreferencesDataSource.preferences.stateIn(
+            scope = applicationScope,
+            started = SharingStarted.Eagerly,
+            initialValue = PlayerPreferences(),
+        )
+
+    override suspend fun updateApplicationPreferences(
+        transform: suspend (ApplicationPreferences) -> ApplicationPreferences,
+    ) {
+        appPreferencesDataSource.update { currentPreferences ->
+            val sanitizedCurrentPreferences = sanitizeApplicationPreferences(currentPreferences)
+            sanitizeApplicationPreferences(transform(sanitizedCurrentPreferences))
+        }
+    }
+
+    override suspend fun updatePlayerPreferences(
+        transform: suspend (PlayerPreferences) -> PlayerPreferences,
+    ) {
+        playerPreferencesDataSource.update(transform)
+    }
+
+    override suspend fun exportSettings(): SettingsBackup = SettingsBackup(
+        applicationPreferences = applicationPreferences.value,
+        playerPreferences = playerPreferences.value,
+    )
+
+    override suspend fun importSettings(settingsBackup: SettingsBackup) {
+        appPreferencesDataSource.update {
+            sanitizeApplicationPreferences(settingsBackup.applicationPreferences)
+        }
+        playerPreferencesDataSource.update { settingsBackup.playerPreferences }
+    }
+
+    override suspend fun resetPreferences() {
+        appPreferencesDataSource.update { ApplicationPreferences() }
+        playerPreferencesDataSource.update { PlayerPreferences() }
+    }
+
+    private fun sanitizeApplicationPreferences(preferences: ApplicationPreferences): ApplicationPreferences {
+        val sanitizedPreferences = if (!hasManageExternalStorageAccess()) {
+            if (!preferences.shouldIgnoreNoMediaFiles && !preferences.isRecycleBinEnabled) {
+                preferences
+            } else {
+                preferences.copy(
+                    shouldIgnoreNoMediaFiles = false,
+                    isRecycleBinEnabled = false,
+                )
+            }
+        } else {
+            preferences
+        }
+        if (sanitizedPreferences.shouldIgnoreNoMediaFiles) {
+            return sanitizedPreferences
+        }
+
+        val visibleManualPaths = sanitizedPreferences.manualVideoPaths.excludeNoMediaPaths()
+        val visiblePendingPaths = sanitizedPreferences.pendingExternalVideoPaths.excludeNoMediaPaths()
+        if (visibleManualPaths.size == sanitizedPreferences.manualVideoPaths.size &&
+            visiblePendingPaths.size == sanitizedPreferences.pendingExternalVideoPaths.size
+        ) {
+            return sanitizedPreferences
+        }
+
+        return sanitizedPreferences.copy(
+            manualVideoPaths = visibleManualPaths,
+            pendingExternalVideoPaths = visiblePendingPaths,
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalSearchHistoryRepository.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalSearchHistoryRepository.kt
new file mode 100644
index 000000000..5844804c3
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalSearchHistoryRepository.kt
@@ -0,0 +1,31 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import app.gyrolet.mpvrx.exoplayer.core.datastore.datasource.SearchHistoryDataSource
+
+class LocalSearchHistoryRepository(
+    private val searchHistoryDataSource: SearchHistoryDataSource,
+) : SearchHistoryRepository {
+
+    override val searchHistory: Flow<List<String>> =
+        searchHistoryDataSource.searchHistory.map { it.queries }
+
+    override suspend fun addSearchQuery(query: String) {
+        searchHistoryDataSource.update { history ->
+            history.addQuery(query)
+        }
+    }
+
+    override suspend fun removeSearchQuery(query: String) {
+        searchHistoryDataSource.update { history ->
+            history.removeQuery(query)
+        }
+    }
+
+    override suspend fun clearHistory() {
+        searchHistoryDataSource.update { history ->
+            history.clear()
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalSubtitleFontRepository.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalSubtitleFontRepository.kt
new file mode 100644
index 000000000..fe662a517
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/LocalSubtitleFontRepository.kt
@@ -0,0 +1,275 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import android.content.ContentResolver
+import android.content.Context
+import android.net.Uri
+import android.provider.OpenableColumns
+import java.io.File
+import java.io.IOException
+import java.nio.file.AtomicMoveNotSupportedException
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.put
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.externalSubtitleFontDir
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.externalSubtitleFontFile
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.externalSubtitleFontMetaFile
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.externalSubtitleFontTempFile
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.externalSubtitleFontTempMetaFile
+import app.gyrolet.mpvrx.exoplayer.core.data.model.ExternalSubtitleFontMeta
+
+class LocalSubtitleFontRepository(
+    private val context: Context,
+    private val applicationScope: CoroutineScope,
+    private val ioDispatcher: CoroutineDispatcher,
+    private val subtitleFontFileValidator: SubtitleFontFileValidator,
+) : SubtitleFontRepository {
+
+    companion object {
+        private const val TAG = "LocalSubtitleFontRepository"
+    }
+
+    private val json = Json {
+        ignoreUnknownKeys = true
+    }
+    private val writeMutex = Mutex()
+    private val stateInternal = MutableStateFlow(ExternalSubtitleFontState())
+    private val sourceInternal = MutableStateFlow<ExternalSubtitleFontSource?>(null)
+
+    override val state: StateFlow<ExternalSubtitleFontState> = stateInternal.asStateFlow()
+    override val source: StateFlow<ExternalSubtitleFontSource?> = sourceInternal.asStateFlow()
+
+    init {
+        applicationScope.launch {
+            refreshState()
+        }
+    }
+
+    override suspend fun importFont(uri: Uri) {
+        writeMutex.withLock {
+            withContext(ioDispatcher) {
+                importFontLocked(uri)
+                refreshStateLocked()
+            }
+        }
+    }
+
+    override suspend fun clearFont() {
+        writeMutex.withLock {
+            withContext(ioDispatcher) {
+                clearFormalArtifacts()
+                clearTempArtifacts()
+                refreshStateLocked()
+            }
+        }
+    }
+
+    private suspend fun refreshState() {
+        writeMutex.withLock {
+            withContext(ioDispatcher) {
+                refreshStateLocked()
+            }
+        }
+    }
+
+    private fun importFontLocked(uri: Uri) {
+        val displayName = resolveDisplayName(uri)
+        val extension = displayName.substringAfterLast('.', "").lowercase()
+        require(extension == "ttf" || extension == "otf") { "Unsupported font extension: $extension" }
+
+        clearTempArtifacts()
+        val tempFontFile = context.externalSubtitleFontTempFile
+        val tempMetaFile = context.externalSubtitleFontTempMetaFile
+
+        runCatching {
+            context.contentResolver.openInputStream(uri)?.use { inputStream ->
+                tempFontFile.outputStream().use { outputStream ->
+                    inputStream.copyTo(outputStream)
+                }
+            } ?: error("Unable to open font input stream")
+
+            validateFontFile(tempFontFile)
+
+            tempMetaFile.writeText(
+                buildJsonObject {
+                    put("displayName", displayName)
+                }.toString(),
+            )
+
+            commitTempArtifacts(tempFontFile = tempFontFile, tempMetaFile = tempMetaFile)
+        }.onFailure { throwable ->
+            clearTempArtifacts()
+            Logger.error(TAG, "Failed to import subtitle font: $displayName", throwable)
+            throw throwable
+        }
+    }
+
+    private fun refreshStateLocked() {
+        clearTempArtifacts()
+
+        val fontFile = context.externalSubtitleFontFile
+        val metaFile = context.externalSubtitleFontMetaFile
+
+        if (!fontFile.exists() && !metaFile.exists()) {
+            publishEmptyState()
+            return
+        }
+
+        val meta = readMeta(metaFile)
+        if (meta == null || !fontFile.exists()) {
+            clearFormalArtifacts()
+            publishEmptyState()
+            return
+        }
+
+        val isFontValid = runCatching {
+            validateFontFile(fontFile)
+        }.isSuccess
+        if (!isFontValid) {
+            clearFormalArtifacts()
+            publishEmptyState()
+            return
+        }
+
+        stateInternal.value = ExternalSubtitleFontState(
+            isAvailable = true,
+            displayName = meta.displayName,
+        )
+        sourceInternal.value = ExternalSubtitleFontSource(
+            absolutePath = fontFile.absolutePath,
+        )
+    }
+
+    private fun readMeta(metaFile: File): ExternalSubtitleFontMeta? {
+        if (!metaFile.exists()) return null
+        return runCatching {
+            val jsonObject = json.parseToJsonElement(metaFile.readText()).jsonObject
+            ExternalSubtitleFontMeta(
+                displayName = jsonObject.getValue("displayName").jsonPrimitive.content,
+            )
+        }.onFailure { throwable ->
+            Logger.error(TAG, "Failed to read external subtitle font meta", throwable)
+        }.getOrNull()
+    }
+
+    private fun resolveDisplayName(uri: Uri): String {
+        val displayName = context.contentResolver.queryDisplayName(uri)
+            ?: uri.lastPathSegment?.substringAfterLast('/')
+            ?: ""
+        require(displayName.isNotBlank()) { "Unable to resolve font display name" }
+        return displayName
+    }
+
+    private fun ContentResolver.queryDisplayName(uri: Uri): String? = query(
+        uri,
+        arrayOf(OpenableColumns.DISPLAY_NAME),
+        null,
+        null,
+        null,
+    )?.use { cursor ->
+        if (!cursor.moveToFirst()) return@use null
+        val index = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+        if (index == -1) return@use null
+        cursor.getString(index)
+    }
+
+    private fun validateFontFile(file: File) {
+        subtitleFontFileValidator.validate(file)
+    }
+
+    private fun commitTempArtifacts(
+        tempFontFile: File,
+        tempMetaFile: File,
+    ) {
+        val formalFontFile = context.externalSubtitleFontFile
+        val formalMetaFile = context.externalSubtitleFontMetaFile
+        val fontBackupFile = File(context.externalSubtitleFontDir, "current.font.bak")
+        val metaBackupFile = File(context.externalSubtitleFontDir, "current.json.bak")
+
+        runCatching {
+            backupIfExists(formalFontFile, fontBackupFile)
+            backupIfExists(formalMetaFile, metaBackupFile)
+
+            moveFile(tempFontFile, formalFontFile)
+            moveFile(tempMetaFile, formalMetaFile)
+
+            fontBackupFile.delete()
+            metaBackupFile.delete()
+        }.onFailure { throwable ->
+            restoreBackup(formalFontFile, fontBackupFile)
+            restoreBackup(formalMetaFile, metaBackupFile)
+            Logger.error(TAG, "Failed to commit subtitle font artifacts", throwable)
+            throw throwable
+        }
+    }
+
+    private fun backupIfExists(
+        sourceFile: File,
+        backupFile: File,
+    ) {
+        if (!sourceFile.exists()) return
+        moveFile(sourceFile, backupFile)
+    }
+
+    private fun restoreBackup(
+        targetFile: File,
+        backupFile: File,
+    ) {
+        if (targetFile.exists()) {
+            targetFile.delete()
+        }
+        if (!backupFile.exists()) return
+        moveFile(backupFile, targetFile)
+    }
+
+    private fun moveFile(
+        sourceFile: File,
+        targetFile: File,
+    ) {
+        targetFile.parentFile?.mkdirs()
+        try {
+            Files.move(
+                sourceFile.toPath(),
+                targetFile.toPath(),
+                StandardCopyOption.REPLACE_EXISTING,
+                StandardCopyOption.ATOMIC_MOVE,
+            )
+        } catch (_: AtomicMoveNotSupportedException) {
+            Files.move(
+                sourceFile.toPath(),
+                targetFile.toPath(),
+                StandardCopyOption.REPLACE_EXISTING,
+            )
+        } catch (exception: IOException) {
+            throw exception
+        }
+    }
+
+    private fun clearFormalArtifacts() {
+        context.externalSubtitleFontFile.delete()
+        context.externalSubtitleFontMetaFile.delete()
+    }
+
+    private fun clearTempArtifacts() {
+        context.externalSubtitleFontTempFile.delete()
+        context.externalSubtitleFontTempMetaFile.delete()
+    }
+
+    private fun publishEmptyState() {
+        stateInternal.value = ExternalSubtitleFontState()
+        sourceInternal.value = null
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/MediaRepository.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/MediaRepository.kt
new file mode 100644
index 000000000..d62659bf4
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/MediaRepository.kt
@@ -0,0 +1,59 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import android.net.Uri
+import kotlinx.coroutines.flow.Flow
+import app.gyrolet.mpvrx.exoplayer.core.data.models.RemotePlaybackInfo
+import app.gyrolet.mpvrx.exoplayer.core.data.models.VideoState
+import app.gyrolet.mpvrx.exoplayer.core.model.Folder
+import app.gyrolet.mpvrx.exoplayer.core.model.Video
+
+interface MediaRepository {
+    fun getVideosFlow(): Flow<List<Video>>
+    fun getVideosFlowFromFolderPath(folderPath: String): Flow<List<Video>>
+    fun getRecycleBinVideosFlow(): Flow<List<Video>>
+    fun getFoldersFlow(): Flow<List<Folder>>
+
+    suspend fun getVideoByUri(uri: String): Video?
+    suspend fun getVideoState(uri: String): VideoState?
+    suspend fun getVideoState(uris: List<String>): VideoState?
+    suspend fun getCanonicalMediaUri(uri: String): String
+    suspend fun getRemotePlaybackStates(stateKeys: List<String>): Map<String, RemotePlaybackInfo>
+
+    suspend fun updateMediumLastPlayedTime(uri: String, lastPlayedTime: Long)
+    suspend fun updateMediumPosition(uri: String, position: Long)
+    suspend fun updateMediumPlaybackSpeed(uri: String, playbackSpeed: Float)
+    suspend fun updateMediumAudioTrack(uri: String, audioTrackIndex: Int)
+    suspend fun updateMediumSubtitleTrack(uri: String, subtitleTrackIndex: Int)
+    suspend fun updateMediumZoom(uri: String, zoom: Float)
+    suspend fun addExternalSubtitleToMedium(uri: String, subtitleUri: Uri)
+    suspend fun updateExternalSubs(uri: String, externalSubs: List<Uri>)
+    suspend fun updateSubtitleDelay(uri: String, delay: Long)
+    suspend fun updateSubtitleSpeed(uri: String, speed: Float)
+    suspend fun moveVideosToRecycleBin(uris: List<String>)
+    suspend fun moveVideosToFolder(
+        uris: List<String>,
+        targetFolderPath: String,
+        shouldCancel: () -> Boolean = { false },
+        onProgress: (Int) -> Unit = {},
+    ): MediaMoveSummary
+
+    suspend fun moveFoldersToFolder(
+        folderPaths: List<String>,
+        targetFolderPath: String,
+        shouldCancel: () -> Boolean = { false },
+        onProgress: (Int) -> Unit = {},
+    ): MediaMoveSummary
+    suspend fun restoreVideosFromRecycleBin(uris: List<String>)
+}
+
+data class MediaMoveSummary(
+    val movedCount: Int = 0,
+    val failedCount: Int = 0,
+    val canceledCount: Int = 0,
+) {
+    operator fun plus(other: MediaMoveSummary): MediaMoveSummary = MediaMoveSummary(
+        movedCount = movedCount + other.movedCount,
+        failedCount = failedCount + other.failedCount,
+        canceledCount = canceledCount + other.canceledCount,
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/OnlineSubtitleRepository.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/OnlineSubtitleRepository.kt
new file mode 100644
index 000000000..e9bac1a47
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/OnlineSubtitleRepository.kt
@@ -0,0 +1,203 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import android.content.Context
+import android.net.Uri
+import java.io.File
+import java.io.FilterInputStream
+import java.io.IOException
+import java.io.InputStream
+import java.net.URI
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+
+class OnlineSubtitleRepository(
+    private val cacheRoot: File,
+    private val downloader: suspend (String) -> DownloadStream,
+    private val nowMillis: () -> Long,
+) {
+
+    constructor(
+        context: Context,
+    ) : this(
+        cacheRoot = context.cacheDir,
+        downloader = { url -> downloadWithOkHttp(url) },
+        nowMillis = System::currentTimeMillis,
+    )
+
+    private val subtitleCacheDir = File(cacheRoot, ONLINE_SUBTITLE_DIR_NAME)
+
+    suspend fun downloadSubtitle(url: String): DownloadedOnlineSubtitle {
+        val parsedUrl = ParsedSubtitleUrl.from(url)
+        subtitleCacheDir.mkdirs()
+
+        val baseName = url.hashCode().toUInt().toString(16)
+        val targetFile = File(subtitleCacheDir, "$baseName.${parsedUrl.extension}")
+        val tempFile = File.createTempFile(baseName, ".${parsedUrl.extension}.part", subtitleCacheDir)
+        Logger.debug(TAG, "Download online subtitle start: extension=${parsedUrl.extension}, target=${targetFile.name}")
+
+        try {
+            downloader(url).inputStream.use { inputStream ->
+                tempFile.outputStream().use { outputStream ->
+                    val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+                    var totalBytes = 0L
+
+                    while (true) {
+                        val readCount = inputStream.read(buffer)
+                        if (readCount == -1) break
+
+                        totalBytes += readCount
+                        // 超限立即终止，避免落盘超出上限的字幕。
+                        if (totalBytes > MAX_SUBTITLE_BYTES) {
+                            throw OnlineSubtitleTooLargeException()
+                        }
+                        outputStream.write(buffer, 0, readCount)
+                    }
+
+                    if (totalBytes == 0L) {
+                        throw EmptyOnlineSubtitleException()
+                    }
+                }
+            }
+
+            if (targetFile.exists()) {
+                targetFile.delete()
+            }
+            if (!tempFile.renameTo(targetFile)) {
+                throw IOException("Unable to move subtitle file")
+            }
+            targetFile.setLastModified(nowMillis())
+            Logger.debug(TAG, "Download online subtitle cached: file=${targetFile.name}, bytes=${targetFile.length()}")
+            return DownloadedOnlineSubtitle(file = targetFile)
+        } catch (exception: EmptyOnlineSubtitleException) {
+            tempFile.delete()
+            throw exception
+        } catch (exception: OnlineSubtitleTooLargeException) {
+            tempFile.delete()
+            throw exception
+        } catch (exception: IOException) {
+            tempFile.delete()
+            throw OnlineSubtitleDownloadFailedException(exception)
+        }
+    }
+
+    fun deleteExpiredSubtitles() {
+        val expireBefore = nowMillis() - SUBTITLE_TTL_MILLIS
+        val files = subtitleCacheDir.listFiles().orEmpty()
+
+        files.forEach { file ->
+            if (file.isFile && file.lastModified() < expireBefore) {
+                file.delete()
+            }
+        }
+    }
+
+    fun touchSubtitle(uri: Uri) {
+        if (uri.scheme != "file") return
+        val file = uri.path?.let(::File) ?: return
+        touchSubtitleFile(file)
+    }
+
+    internal fun touchSubtitleFile(file: File) {
+        if (!file.isFile) return
+        if (file.parentFile?.canonicalFile != subtitleCacheDir.canonicalFile) return
+
+        file.setLastModified(nowMillis())
+    }
+
+    private data class ParsedSubtitleUrl(
+        val extension: String,
+    ) {
+        companion object {
+            fun from(url: String): ParsedSubtitleUrl {
+                val uri = runCatching { URI(url.trim()) }
+                    .getOrElse { throw InvalidOnlineSubtitleUrlException() }
+                val scheme = uri.scheme?.lowercase().orEmpty()
+                if (scheme !in SUPPORTED_SCHEMES) {
+                    throw InvalidOnlineSubtitleSchemeException(scheme)
+                }
+                if (uri.host.isNullOrBlank()) {
+                    throw InvalidOnlineSubtitleUrlException()
+                }
+
+                val extension = uri.path.orEmpty().substringAfterLast('.', "").lowercase()
+                if (extension !in SUPPORTED_EXTENSIONS) {
+                    throw InvalidOnlineSubtitleExtensionException(extension)
+                }
+
+                return ParsedSubtitleUrl(extension = extension)
+            }
+        }
+    }
+
+    private companion object {
+        const val TAG = "OnlineSubtitleRepository"
+        const val ONLINE_SUBTITLE_DIR_NAME = "online_subtitles"
+        const val MAX_SUBTITLE_BYTES = 10L * 1024 * 1024
+        const val SUBTITLE_TTL_MILLIS = 7L * 24 * 60 * 60 * 1000
+        val SUPPORTED_SCHEMES = setOf("http", "https")
+        val SUPPORTED_EXTENSIONS = setOf("srt", "ass", "ssa", "vtt")
+
+        fun downloadWithOkHttp(url: String): DownloadStream {
+            val request = Request.Builder()
+                .url(url)
+                .build()
+            val response = OkHttpClient.Builder().build().newCall(request).execute()
+            if (!response.isSuccessful) {
+                response.close()
+                throw IOException("Subtitle download failed with code ${response.code}")
+            }
+
+            val body = response.body
+            if (body == null) {
+                response.close()
+                throw IOException("Subtitle response body is empty")
+            }
+
+            return DownloadStream(ResponseInputStream(body.byteStream(), response::close))
+        }
+    }
+}
+
+data class DownloadedOnlineSubtitle(
+    val file: File,
+) {
+    val uriString: String = file.toURI().toString()
+    val uri: Uri get() = Uri.parse(uriString)
+}
+
+class DownloadStream(
+    val inputStream: InputStream,
+)
+
+class InvalidOnlineSubtitleSchemeException(
+    val scheme: String,
+) : IllegalArgumentException("Unsupported subtitle scheme: $scheme")
+
+class InvalidOnlineSubtitleUrlException : IllegalArgumentException("Unsupported subtitle URL")
+
+class InvalidOnlineSubtitleExtensionException(
+    val extension: String,
+) : IllegalArgumentException("Unsupported subtitle extension: $extension")
+
+class EmptyOnlineSubtitleException : IllegalStateException("Online subtitle is empty")
+
+class OnlineSubtitleTooLargeException : IllegalStateException("Online subtitle exceeds 10 MB")
+
+class OnlineSubtitleDownloadFailedException(
+    cause: IOException,
+) : IOException("Online subtitle download failed", cause)
+
+private class ResponseInputStream(
+    inputStream: InputStream,
+    private val onClose: () -> Unit,
+) : FilterInputStream(inputStream) {
+
+    override fun close() {
+        try {
+            super.close()
+        } finally {
+            onClose()
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/PreferencesRepository.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/PreferencesRepository.kt
new file mode 100644
index 000000000..b4193e274
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/PreferencesRepository.kt
@@ -0,0 +1,25 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import kotlinx.coroutines.flow.StateFlow
+import app.gyrolet.mpvrx.exoplayer.core.model.ApplicationPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.SettingsBackup
+
+interface PreferencesRepository {
+
+    val applicationPreferences: StateFlow<ApplicationPreferences>
+
+    val playerPreferences: StateFlow<PlayerPreferences>
+
+    suspend fun updateApplicationPreferences(
+        transform: suspend (ApplicationPreferences) -> ApplicationPreferences,
+    )
+
+    suspend fun updatePlayerPreferences(transform: suspend (PlayerPreferences) -> PlayerPreferences)
+
+    suspend fun exportSettings(): SettingsBackup
+
+    suspend fun importSettings(settingsBackup: SettingsBackup)
+
+    suspend fun resetPreferences()
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/RemotePlaybackStateKey.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/RemotePlaybackStateKey.kt
new file mode 100644
index 000000000..ec32f267c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/RemotePlaybackStateKey.kt
@@ -0,0 +1,45 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import android.net.Uri
+
+private const val REMOTE_PLAYBACK_STATE_PREFIX = "onlyplayer://remote"
+private val SUPPORTED_REMOTE_PROTOCOLS = setOf("webdav", "ftp")
+
+fun buildRemotePlaybackStateKey(
+    remoteProtocol: String?,
+    remoteServerId: Long?,
+    remoteFilePath: String?,
+): String? {
+    val protocol = remoteProtocol?.lowercase()?.takeIf { it in SUPPORTED_REMOTE_PROTOCOLS } ?: return null
+    val serverId = remoteServerId?.takeIf { it > 0L } ?: return null
+    val normalizedPath = remoteFilePath.normalizeRemotePlaybackPath() ?: return null
+    return "$REMOTE_PLAYBACK_STATE_PREFIX/$protocol/$serverId$normalizedPath"
+}
+
+fun buildPlaybackStateCandidates(
+    originalUri: String,
+    remoteProtocol: String?,
+    remoteServerId: Long?,
+    remoteFilePath: String?,
+): List<String> {
+    val stableKey = buildRemotePlaybackStateKey(
+        remoteProtocol = remoteProtocol,
+        remoteServerId = remoteServerId,
+        remoteFilePath = remoteFilePath,
+    )
+    return listOfNotNull(stableKey, originalUri).distinct()
+}
+
+fun String.isRemotePlaybackStateKey(): Boolean = startsWith("$REMOTE_PLAYBACK_STATE_PREFIX/")
+
+private fun String?.normalizeRemotePlaybackPath(): String? {
+    val raw = this?.trim().orEmpty()
+    if (raw.isBlank()) return null
+    val decoded = runCatching { Uri.decode(raw) }.getOrDefault(raw)
+    val normalized = decoded
+        .replace(Regex("/+"), "/")
+        .removeSuffix("/")
+        .takeIf { it.isNotBlank() && it != "/" }
+        ?: return null
+    return if (normalized.startsWith('/')) normalized else "/$normalized"
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/SearchHistoryRepository.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/SearchHistoryRepository.kt
new file mode 100644
index 000000000..e46da4e34
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/SearchHistoryRepository.kt
@@ -0,0 +1,14 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import kotlinx.coroutines.flow.Flow
+
+interface SearchHistoryRepository {
+
+    val searchHistory: Flow<List<String>>
+
+    suspend fun addSearchQuery(query: String)
+
+    suspend fun removeSearchQuery(query: String)
+
+    suspend fun clearHistory()
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/SubtitleFontFileValidator.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/SubtitleFontFileValidator.kt
new file mode 100644
index 000000000..d8b823b49
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/SubtitleFontFileValidator.kt
@@ -0,0 +1,13 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import java.io.File
+
+class SubtitleFontFileValidator {
+    fun validate(file: File) {
+        // Basic validation: check if file is not empty
+        if (file.length() == 0L) {
+            throw IllegalArgumentException("Font file is empty")
+        }
+        // More advanced validation could check font headers (e.g., TTF/OTF magic numbers)
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/SubtitleFontRepository.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/SubtitleFontRepository.kt
new file mode 100644
index 000000000..02b91b169
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/data/repository/SubtitleFontRepository.kt
@@ -0,0 +1,23 @@
+package app.gyrolet.mpvrx.exoplayer.core.data.repository
+
+import android.net.Uri
+import kotlinx.coroutines.flow.StateFlow
+
+interface SubtitleFontRepository {
+    val state: StateFlow<ExternalSubtitleFontState>
+
+    val source: StateFlow<ExternalSubtitleFontSource?>
+
+    suspend fun importFont(uri: Uri)
+
+    suspend fun clearFont()
+}
+
+data class ExternalSubtitleFontState(
+    val isAvailable: Boolean = false,
+    val displayName: String = "",
+)
+
+data class ExternalSubtitleFontSource(
+    val absolutePath: String,
+)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/AppPreferencesDataSource.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/AppPreferencesDataSource.kt
new file mode 100644
index 000000000..951bc0027
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/AppPreferencesDataSource.kt
@@ -0,0 +1,26 @@
+package app.gyrolet.mpvrx.exoplayer.core.datastore.datasource
+
+import androidx.datastore.core.DataStore
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.model.ApplicationPreferences
+
+class AppPreferencesDataSource(
+    private val appPreferences: DataStore<ApplicationPreferences>,
+) : PreferencesDataSource<ApplicationPreferences> {
+
+    companion object {
+        private const val TAG = "AppPreferencesDataSource"
+    }
+
+    override val preferences = appPreferences.data
+
+    override suspend fun update(
+        transform: suspend (ApplicationPreferences) -> ApplicationPreferences,
+    ) {
+        try {
+            appPreferences.updateData(transform)
+        } catch (ioException: Exception) {
+            Logger.error(TAG, "Failed to update app preferences: $ioException")
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/PlayerPreferencesDataSource.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/PlayerPreferencesDataSource.kt
new file mode 100644
index 000000000..4278fdd38
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/PlayerPreferencesDataSource.kt
@@ -0,0 +1,24 @@
+package app.gyrolet.mpvrx.exoplayer.core.datastore.datasource
+
+import androidx.datastore.core.DataStore
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+
+class PlayerPreferencesDataSource(
+    private val preferencesDataStore: DataStore<PlayerPreferences>,
+) : PreferencesDataSource<PlayerPreferences> {
+
+    companion object {
+        private const val TAG = "PlayerPreferencesDataSource"
+    }
+
+    override val preferences = preferencesDataStore.data
+
+    override suspend fun update(transform: suspend (PlayerPreferences) -> PlayerPreferences) {
+        try {
+            preferencesDataStore.updateData(transform)
+        } catch (ioException: Exception) {
+            Logger.error(TAG, "Failed to update app preferences: $ioException")
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/PreferencesDataSource.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/PreferencesDataSource.kt
new file mode 100644
index 000000000..8811eab52
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/PreferencesDataSource.kt
@@ -0,0 +1,10 @@
+package app.gyrolet.mpvrx.exoplayer.core.datastore.datasource
+
+import kotlinx.coroutines.flow.Flow
+
+interface PreferencesDataSource<T> {
+
+    val preferences: Flow<T>
+
+    suspend fun update(transform: suspend (T) -> T)
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/SearchHistoryDataSource.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/SearchHistoryDataSource.kt
new file mode 100644
index 000000000..f6dd179ef
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/datasource/SearchHistoryDataSource.kt
@@ -0,0 +1,27 @@
+package app.gyrolet.mpvrx.exoplayer.core.datastore.datasource
+
+import androidx.datastore.core.DataStore
+import kotlinx.coroutines.flow.Flow
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.model.SearchHistory
+
+class SearchHistoryDataSource(
+    private val searchHistoryDataStore: DataStore<SearchHistory>,
+) {
+
+    companion object {
+        private const val TAG = "SearchHistoryDataSource"
+    }
+
+    val searchHistory: Flow<SearchHistory> = searchHistoryDataStore.data
+
+    suspend fun update(
+        transform: suspend (SearchHistory) -> SearchHistory,
+    ) {
+        try {
+            searchHistoryDataStore.updateData(transform)
+        } catch (ioException: Exception) {
+            Logger.error(TAG, "Failed to update search history: $ioException")
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/serializer/ApplicationPreferencesSerializer.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/serializer/ApplicationPreferencesSerializer.kt
new file mode 100644
index 000000000..5129df098
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/serializer/ApplicationPreferencesSerializer.kt
@@ -0,0 +1,65 @@
+package app.gyrolet.mpvrx.exoplayer.core.datastore.serializer
+
+import androidx.datastore.core.CorruptionException
+import androidx.datastore.core.Serializer
+import java.io.InputStream
+import java.io.OutputStream
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonObject
+import app.gyrolet.mpvrx.exoplayer.core.model.ApplicationPreferences
+
+object ApplicationPreferencesSerializer : Serializer<ApplicationPreferences> {
+
+    private val jsonFormat = Json { ignoreUnknownKeys = true }
+    private val legacyKeys = setOf(
+        "ignoreNoMediaFiles",
+        "markLastPlayedMedia",
+        "showDurationField",
+        "showExtensionField",
+        "showPathField",
+        "showPlayedProgress",
+        "showResolutionField",
+        "showSizeField",
+        "showThumbnailField",
+        "useDynamicColors",
+    )
+
+    override val defaultValue: ApplicationPreferences
+        get() = ApplicationPreferences()
+
+    override suspend fun readFrom(input: InputStream): ApplicationPreferences {
+        val serializedPreferences = input.readBytes().decodeToString()
+
+        if (serializedPreferences.containsLegacyApplicationPreferences()) {
+            throw CorruptionException(
+                message = "Cannot read datastore",
+                cause = IllegalStateException("Legacy application preferences format is unsupported"),
+            )
+        }
+
+        try {
+            return jsonFormat.decodeFromString(
+                deserializer = ApplicationPreferences.serializer(),
+                string = serializedPreferences,
+            )
+        } catch (exception: SerializationException) {
+            throw CorruptionException("Cannot read datastore", exception)
+        }
+    }
+
+    @Suppress("BlockingMethodInNonBlockingContext")
+    override suspend fun writeTo(t: ApplicationPreferences, output: OutputStream) {
+        output.write(
+            jsonFormat.encodeToString(
+                serializer = ApplicationPreferences.serializer(),
+                value = t,
+            ).encodeToByteArray(),
+        )
+    }
+
+    private fun String.containsLegacyApplicationPreferences(): Boolean {
+        val root = runCatching { jsonFormat.parseToJsonElement(this).jsonObject }.getOrNull() ?: return false
+        return root.keys.any(legacyKeys::contains)
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/serializer/PlayerPreferencesSerializer.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/serializer/PlayerPreferencesSerializer.kt
new file mode 100644
index 000000000..b47277616
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/serializer/PlayerPreferencesSerializer.kt
@@ -0,0 +1,144 @@
+package app.gyrolet.mpvrx.exoplayer.core.datastore.serializer
+
+import androidx.datastore.core.CorruptionException
+import androidx.datastore.core.Serializer
+import java.io.InputStream
+import java.io.OutputStream
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerIconStyle
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+
+object PlayerPreferencesSerializer : Serializer<PlayerPreferences> {
+
+    private const val LEGACY_DEFAULT_MAX_INITIAL_PLAYER_VOLUME_PERCENTAGE = 100
+
+    private val jsonFormat = Json {
+        ignoreUnknownKeys = true
+        encodeDefaults = true
+    }
+    private val videoFilterEnabledKeys = setOf(
+        "isVideoBrightnessFilterEnabled",
+        "isVideoContrastFilterEnabled",
+        "isVideoSaturationFilterEnabled",
+        "isVideoHueFilterEnabled",
+        "isVideoGammaFilterEnabled",
+        "isVideoSharpeningFilterEnabled",
+    )
+    private val legacyKeys = setOf(
+        "applyEmbeddedStyles",
+        "autoBackgroundPlay",
+        "autoPip",
+        "autoplay",
+        "enableBrightnessSwipeGesture",
+        "enablePanGesture",
+        "enableVolumeBoost",
+        "enableVolumeSwipeGesture",
+        "hidePlayerButtonsBackground",
+        "pauseOnHeadsetDisconnect",
+        "rememberPlayerBrightness",
+        "rememberSelections",
+        "requireAudioFocus",
+        "shouldUseLibass",
+        "showSystemVolumePanel",
+        "subtitleBackground",
+        "subtitleTextBold",
+        "useLongPressControls",
+        "useSeekControls",
+        "useSwipeControls",
+        "useSystemCaptionStyle",
+        "useZoomControls",
+    )
+
+    override val defaultValue: PlayerPreferences
+        get() = PlayerPreferences()
+
+    override suspend fun readFrom(input: InputStream): PlayerPreferences {
+        val serializedPreferences = input.readBytes().decodeToString()
+
+        if (serializedPreferences.containsLegacyPlayerPreferences()) {
+            throw CorruptionException(
+                message = "Cannot read datastore",
+                cause = IllegalStateException("Legacy player preferences format is unsupported"),
+            )
+        }
+
+        try {
+            val preferences = jsonFormat.decodeFromString(
+                deserializer = PlayerPreferences.serializer(),
+                string = serializedPreferences,
+            )
+            return preferences.upgradeLegacyDefaults(serializedPreferences)
+        } catch (exception: SerializationException) {
+            throw CorruptionException("Cannot read datastore", exception)
+        }
+    }
+
+    @Suppress("BlockingMethodInNonBlockingContext")
+    override suspend fun writeTo(t: PlayerPreferences, output: OutputStream) {
+        output.write(
+            jsonFormat.encodeToString(
+                serializer = PlayerPreferences.serializer(),
+                value = t,
+            ).encodeToByteArray(),
+        )
+    }
+
+    private fun PlayerPreferences.upgradeLegacyDefaults(serializedPreferences: String): PlayerPreferences {
+        val root = runCatching { jsonFormat.parseToJsonElement(serializedPreferences).jsonObject }.getOrNull() ?: return this
+        val persistedInitialVolumeLimit = root["maxInitialPlayerVolumePercentage"]?.jsonPrimitive?.content?.toIntOrNull()
+        var upgradedPreferences = if (persistedInitialVolumeLimit == LEGACY_DEFAULT_MAX_INITIAL_PLAYER_VOLUME_PERCENTAGE) {
+            copy(maxInitialPlayerVolumePercentage = PlayerPreferences.DEFAULT_MAX_INITIAL_PLAYER_VOLUME_PERCENTAGE)
+        } else {
+            this
+        }
+
+        if ("shouldApplyVideoFilters" !in root && hasAdjustedVideoFilters()) {
+            upgradedPreferences = upgradedPreferences.copy(shouldApplyVideoFilters = true)
+        }
+        if ("playerIconStyle" !in root && root["shouldUseClassicPlayerIcons"]?.jsonPrimitive?.content == "true") {
+            upgradedPreferences = upgradedPreferences.copy(playerIconStyle = PlayerIconStyle.CLASSIC)
+        }
+        if (!root.keys.containsAll(videoFilterEnabledKeys)) {
+            upgradedPreferences = upgradedPreferences.copy(
+                isVideoBrightnessFilterEnabled = upgradedPreferences.isVideoBrightnessFilterEnabled.takeIf {
+                    "isVideoBrightnessFilterEnabled" in root
+                } ?: (upgradedPreferences.videoBrightness != PlayerPreferences.DEFAULT_VIDEO_BRIGHTNESS),
+                isVideoContrastFilterEnabled = upgradedPreferences.isVideoContrastFilterEnabled.takeIf {
+                    "isVideoContrastFilterEnabled" in root
+                } ?: (upgradedPreferences.videoContrast != PlayerPreferences.DEFAULT_VIDEO_CONTRAST),
+                isVideoSaturationFilterEnabled = upgradedPreferences.isVideoSaturationFilterEnabled.takeIf {
+                    "isVideoSaturationFilterEnabled" in root
+                } ?: (upgradedPreferences.videoSaturation != PlayerPreferences.DEFAULT_VIDEO_SATURATION),
+                isVideoHueFilterEnabled = upgradedPreferences.isVideoHueFilterEnabled.takeIf {
+                    "isVideoHueFilterEnabled" in root
+                } ?: (upgradedPreferences.videoHue != PlayerPreferences.DEFAULT_VIDEO_HUE),
+                isVideoGammaFilterEnabled = upgradedPreferences.isVideoGammaFilterEnabled.takeIf {
+                    "isVideoGammaFilterEnabled" in root
+                } ?: (upgradedPreferences.videoGamma != PlayerPreferences.DEFAULT_VIDEO_GAMMA),
+                isVideoSharpeningFilterEnabled = upgradedPreferences.isVideoSharpeningFilterEnabled.takeIf {
+                    "isVideoSharpeningFilterEnabled" in root
+                } ?: (upgradedPreferences.videoSharpening != PlayerPreferences.DEFAULT_VIDEO_SHARPENING),
+            )
+        }
+
+        return upgradedPreferences
+    }
+
+    private fun PlayerPreferences.hasAdjustedVideoFilters(): Boolean = videoBrightness != PlayerPreferences.DEFAULT_VIDEO_BRIGHTNESS ||
+        videoContrast != PlayerPreferences.DEFAULT_VIDEO_CONTRAST ||
+        videoSaturation != PlayerPreferences.DEFAULT_VIDEO_SATURATION ||
+        videoHue != PlayerPreferences.DEFAULT_VIDEO_HUE ||
+        videoGamma != PlayerPreferences.DEFAULT_VIDEO_GAMMA ||
+        videoSharpening != PlayerPreferences.DEFAULT_VIDEO_SHARPENING
+
+    private fun String.containsLegacyPlayerPreferences(): Boolean {
+        val root = runCatching { jsonFormat.parseToJsonElement(this).jsonObject }.getOrNull() ?: return false
+        if (root.keys.any(legacyKeys::contains)) return true
+
+        val subtitleTextSize = root["subtitleTextSize"]?.jsonPrimitive ?: return false
+        return subtitleTextSize.content.toIntOrNull() == null
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/serializer/SearchHistorySerializer.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/serializer/SearchHistorySerializer.kt
new file mode 100644
index 000000000..c8a1c41ac
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/datastore/serializer/SearchHistorySerializer.kt
@@ -0,0 +1,38 @@
+package app.gyrolet.mpvrx.exoplayer.core.datastore.serializer
+
+import androidx.datastore.core.CorruptionException
+import androidx.datastore.core.Serializer
+import java.io.InputStream
+import java.io.OutputStream
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+import app.gyrolet.mpvrx.exoplayer.core.model.SearchHistory
+
+object SearchHistorySerializer : Serializer<SearchHistory> {
+
+    private val jsonFormat = Json { ignoreUnknownKeys = true }
+
+    override val defaultValue: SearchHistory
+        get() = SearchHistory()
+
+    override suspend fun readFrom(input: InputStream): SearchHistory {
+        try {
+            return jsonFormat.decodeFromString(
+                deserializer = SearchHistory.serializer(),
+                string = input.readBytes().decodeToString(),
+            )
+        } catch (exception: SerializationException) {
+            throw CorruptionException("Cannot read datastore", exception)
+        }
+    }
+
+    @Suppress("BlockingMethodInNonBlockingContext")
+    override suspend fun writeTo(t: SearchHistory, output: OutputStream) {
+        output.write(
+            jsonFormat.encodeToString(
+                serializer = SearchHistory.serializer(),
+                value = t,
+            ).encodeToByteArray(),
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/domain/GetSortedPlaylistUseCase.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/domain/GetSortedPlaylistUseCase.kt
new file mode 100644
index 000000000..901970503
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/domain/GetSortedPlaylistUseCase.kt
@@ -0,0 +1,28 @@
+package app.gyrolet.mpvrx.exoplayer.core.domain
+
+import android.content.Context
+import android.net.Uri
+import java.io.File
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.getPath
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.model.MediaViewMode
+import app.gyrolet.mpvrx.exoplayer.core.model.Video
+
+class GetSortedPlaylistUseCase(
+    private val getSortedVideosUseCase: GetSortedVideosUseCase,
+    private val preferencesRepository: PreferencesRepository,
+    private val context: Context,
+    private val defaultDispatcher: CoroutineDispatcher,
+) {
+    suspend operator fun invoke(uri: Uri): List<Video> = withContext(defaultDispatcher) {
+        val path = context.getPath(uri) ?: return@withContext emptyList()
+        val parent = File(path).parent.takeIf {
+            preferencesRepository.applicationPreferences.first().mediaViewMode != MediaViewMode.VIDEOS
+        }
+
+        getSortedVideosUseCase.invoke(parent).first()
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/domain/GetSortedVideosUseCase.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/domain/GetSortedVideosUseCase.kt
new file mode 100644
index 000000000..8a2136e2a
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/domain/GetSortedVideosUseCase.kt
@@ -0,0 +1,44 @@
+package app.gyrolet.mpvrx.exoplayer.core.domain
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flowOn
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.MediaRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.model.Sort
+import app.gyrolet.mpvrx.exoplayer.core.model.Video
+
+class GetSortedVideosUseCase(
+    private val mediaRepository: MediaRepository,
+    private val preferencesRepository: PreferencesRepository,
+    private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) {
+
+    operator fun invoke(
+        folderPath: String? = null,
+        isRecycleBinOnly: Boolean = false,
+    ): Flow<List<Video>> {
+        val videosFlow = if (isRecycleBinOnly) {
+            mediaRepository.getRecycleBinVideosFlow()
+        } else if (folderPath != null) {
+            mediaRepository.getVideosFlowFromFolderPath(folderPath)
+        } else {
+            mediaRepository.getVideosFlow()
+        }
+
+        return combine(
+            videosFlow,
+            preferencesRepository.applicationPreferences,
+        ) { videoItems, preferences ->
+            val visibleVideos = videoItems.filterNot { video ->
+                (!isRecycleBinOnly && preferences.isPathExcluded(video.parentPath)) ||
+                    (!isRecycleBinOnly && preferences.isRecycleBinEnabled && video.isInRecycleBin)
+            }
+
+            val sort = Sort(by = preferences.sortBy, order = preferences.sortOrder)
+            visibleVideos.sortedWith(sort.videoComparator())
+        }.flowOn(defaultDispatcher)
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ApplicationPreferences.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ApplicationPreferences.kt
new file mode 100644
index 000000000..2c12810e7
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ApplicationPreferences.kt
@@ -0,0 +1,72 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlin.math.roundToInt
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ApplicationPreferences(
+    val appLanguage: String = "",
+    val sortBy: Sort.By = Sort.By.TITLE,
+    val sortOrder: Sort.Order = Sort.Order.ASCENDING,
+    val themeConfig: ThemeConfig = ThemeConfig.SYSTEM,
+    val shouldUseDynamicColors: Boolean = true,
+    val shouldNavigateHomeOnTitleLongPress: Boolean = false,
+    val shouldPreventScreenshots: Boolean = false,
+    val shouldHideInRecents: Boolean = false,
+    val shouldMarkLastPlayedMedia: Boolean = true,
+    val shouldRestoreLastPlayedMediaInFolders: Boolean = false,
+    val shouldIgnoreNoMediaFiles: Boolean = false,
+    val isRecycleBinEnabled: Boolean = false,
+    val excludeFolders: List<String> = emptyList(),
+    val localFolderLastPlayedMediaUris: Map<String, String> = emptyMap(),
+    val remoteFolderLastPlayedMediaPaths: Map<String, String> = emptyMap(),
+    val mediaViewMode: MediaViewMode = MediaViewMode.FOLDERS,
+    val mediaLayoutMode: MediaLayoutMode = MediaLayoutMode.LIST,
+    val mediaLayoutScale: Float = DEFAULT_MEDIA_LAYOUT_SCALE,
+
+    // 字段显示
+    val shouldShowDurationField: Boolean = true,
+    val shouldShowExtensionField: Boolean = false,
+    val shouldShowPathField: Boolean = true,
+    val shouldShowResolutionField: Boolean = false,
+    val shouldShowSizeField: Boolean = false,
+    val shouldShowThumbnailField: Boolean = true,
+    val shouldShowPlayedProgress: Boolean = true,
+
+    // 缩略图生成
+    val thumbnailGenerationStrategy: ThumbnailGenerationStrategy = ThumbnailGenerationStrategy.FRAME_AT_PERCENTAGE,
+    val thumbnailFramePosition: Float = DEFAULT_THUMBNAIL_FRAME_POSITION,
+    val shouldCheckForUpdatesOnStartup: Boolean = false,
+    val manualVideoPaths: List<String> = emptyList(),
+    val pendingExternalVideoPaths: List<String> = emptyList(),
+) {
+
+    fun isPathExcluded(path: String): Boolean {
+        if (path.isBlank()) return false
+
+        return excludeFolders.any { excludedPath ->
+            path == excludedPath || path.startsWith("$excludedPath/")
+        }
+    }
+
+    fun normalizedMediaLayoutScale(): Float = mediaLayoutScale
+        .coerceIn(MIN_MEDIA_LAYOUT_SCALE, MAX_MEDIA_LAYOUT_SCALE)
+        .roundToStep(MEDIA_LAYOUT_SCALE_STEP)
+
+    fun withMediaLayoutScale(scale: Float): ApplicationPreferences = copy(
+        mediaLayoutScale = scale
+            .coerceIn(MIN_MEDIA_LAYOUT_SCALE, MAX_MEDIA_LAYOUT_SCALE)
+            .roundToStep(MEDIA_LAYOUT_SCALE_STEP),
+    )
+
+    companion object {
+        const val DEFAULT_THUMBNAIL_FRAME_POSITION = 0.5f
+        const val DEFAULT_MEDIA_LAYOUT_SCALE = 1f
+        const val MIN_MEDIA_LAYOUT_SCALE = 0.75f
+        const val MAX_MEDIA_LAYOUT_SCALE = 1.5f
+        const val MEDIA_LAYOUT_SCALE_STEP = 0.05f
+    }
+}
+
+private fun Float.roundToStep(step: Float): Float = (this / step).roundToInt() * step
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/AudioStreamInfo.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/AudioStreamInfo.kt
new file mode 100644
index 000000000..9790f5db9
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/AudioStreamInfo.kt
@@ -0,0 +1,17 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import java.io.Serializable
+
+data class AudioStreamInfo(
+    val index: Int,
+    val title: String?,
+    val codecName: String,
+    val language: String?,
+    val disposition: Int,
+    val bitRate: Long,
+    val sampleFormat: String?,
+    val sampleRate: Int,
+    val channels: Int,
+    val channelLayout: String?,
+) : Serializable
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ControlButtonsPosition.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ControlButtonsPosition.kt
new file mode 100644
index 000000000..1d5f193d0
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ControlButtonsPosition.kt
@@ -0,0 +1,10 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class ControlButtonsPosition {
+    LEFT,
+    RIGHT,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/DecoderPriority.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/DecoderPriority.kt
new file mode 100644
index 000000000..0cc0dbbd5
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/DecoderPriority.kt
@@ -0,0 +1,13 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class DecoderPriority {
+    AUTOMATIC,
+    AUTOMATIC_PREFER_DEVICE,
+    DEVICE_ONLY,
+    PREFER_DEVICE,
+    PREFER_APP,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/DoubleTapGesture.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/DoubleTapGesture.kt
new file mode 100644
index 000000000..9e4b9455e
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/DoubleTapGesture.kt
@@ -0,0 +1,12 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class DoubleTapGesture {
+    PLAY_PAUSE,
+    FAST_FORWARD_AND_REWIND,
+    BOTH,
+    NONE,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/FastSeek.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/FastSeek.kt
new file mode 100644
index 000000000..c859daaa8
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/FastSeek.kt
@@ -0,0 +1,8 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+enum class FastSeek {
+    AUTO,
+    ENABLE,
+    DISABLE,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Folder.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Folder.kt
new file mode 100644
index 000000000..4c71a6319
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Folder.kt
@@ -0,0 +1,42 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import java.io.Serializable
+
+data class Folder(
+    val name: String,
+    val path: String,
+    val dateModified: Long,
+    val parentPath: String? = null,
+    val formattedMediaSize: String = "",
+    val mediaList: List<Video> = emptyList(),
+    val folderList: List<Folder> = emptyList(),
+) : Serializable {
+
+    val mediaSize: Long = mediaList.sumOf { it.size } + folderList.sumOf { it.mediaSize }
+    val mediaDuration: Long = mediaList.sumOf { it.duration } + folderList.sumOf { it.mediaDuration }
+    val allMediaList: List<Video> = mediaList + folderList.flatMap { it.allMediaList }
+    val recentlyPlayedVideo: Video? = allMediaList.recentPlayed()
+    val firstVideo: Video? = allMediaList.firstOrNull()
+
+    fun isRecentlyPlayedVideo(video: Video?): Boolean {
+        if (recentlyPlayedVideo == null) return false
+        if (video == null) return false
+        return video.path == recentlyPlayedVideo.path
+    }
+
+    companion object {
+        val rootFolder = Folder(
+            name = "Root",
+            path = "/",
+            dateModified = System.currentTimeMillis(),
+        )
+
+        val sample = Folder(
+            name = "Sample Folder",
+            path = "/storage/emulated/0/Movies/Sample",
+            dateModified = 2000,
+            formattedMediaSize = "1KB",
+        )
+    }
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Font.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Font.kt
new file mode 100644
index 000000000..f873215f0
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Font.kt
@@ -0,0 +1,12 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class Font {
+    DEFAULT,
+    MONOSPACE,
+    SANS_SERIF,
+    SERIF,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/LoopMode.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/LoopMode.kt
new file mode 100644
index 000000000..60aab70fa
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/LoopMode.kt
@@ -0,0 +1,11 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class LoopMode {
+    OFF,
+    ONE,
+    ALL,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/MediaLayoutMode.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/MediaLayoutMode.kt
new file mode 100644
index 000000000..d3f1d6cff
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/MediaLayoutMode.kt
@@ -0,0 +1,10 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class MediaLayoutMode {
+    LIST,
+    GRID,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/MediaViewMode.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/MediaViewMode.kt
new file mode 100644
index 000000000..668c281ec
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/MediaViewMode.kt
@@ -0,0 +1,11 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class MediaViewMode {
+    FOLDER_TREE,
+    FOLDERS,
+    VIDEOS,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerControlsLayout.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerControlsLayout.kt
new file mode 100644
index 000000000..894eaedbe
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerControlsLayout.kt
@@ -0,0 +1,177 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.builtins.ListSerializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.descriptors.buildClassSerialDescriptor
+import kotlinx.serialization.descriptors.element
+import kotlinx.serialization.encoding.CompositeDecoder
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.encoding.decodeStructure
+import kotlinx.serialization.encoding.encodeStructure
+
+@Serializable
+enum class PlayerControlZone {
+    TOP_RIGHT,
+    BOTTOM_LEFT,
+}
+
+@Serializable
+data class PlayerControlLayoutEntry(
+    val control: PlayerControl,
+    val zone: PlayerControlZone,
+)
+
+@Serializable(with = PlayerControlsLayoutSerializer::class)
+class PlayerControlsLayout(
+    entries: List<PlayerControlLayoutEntry> = defaultEntries(),
+) {
+
+    val entries: List<PlayerControlLayoutEntry> = normalizeEntries(entries)
+
+    fun controlsIn(zone: PlayerControlZone): List<PlayerControl> = entries
+        .filter { it.zone == zone }
+        .map { it.control }
+
+    fun move(
+        control: PlayerControl,
+        toZone: PlayerControlZone,
+        toIndex: Int,
+    ): PlayerControlsLayout {
+        if (control !in customizableControls) return this
+
+        val remainingEntries = entries.filterNot { it.control == control }.toMutableList()
+        val targetIndexes = remainingEntries.withIndex()
+            .filter { it.value.zone == toZone }
+            .map { it.index }
+
+        val insertAt = when {
+            targetIndexes.isEmpty() -> remainingEntries.size
+            toIndex <= 0 -> targetIndexes.first()
+            toIndex >= targetIndexes.size -> targetIndexes.last() + 1
+            else -> targetIndexes[toIndex]
+        }
+
+        remainingEntries.add(
+            index = insertAt,
+            element = PlayerControlLayoutEntry(
+                control = control,
+                zone = toZone,
+            ),
+        )
+        return PlayerControlsLayout(remainingEntries)
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is PlayerControlsLayout) return false
+        return entries == other.entries
+    }
+
+    override fun hashCode(): Int = entries.hashCode()
+
+    override fun toString(): String = "PlayerControlsLayout(entries=$entries)"
+
+    companion object {
+        val topRightControls: List<PlayerControl> = listOf(
+            PlayerControl.PLAYLIST,
+            PlayerControl.PLAYBACK_SPEED,
+            PlayerControl.AUDIO,
+            PlayerControl.SUBTITLE,
+        )
+
+        val bottomLeftControls: List<PlayerControl> = listOf(
+            PlayerControl.LOCK,
+            PlayerControl.SCALE,
+            PlayerControl.DECODER,
+            PlayerControl.AMBIENCE_MODE,
+            PlayerControl.VIDEO_FILTERS,
+            PlayerControl.PIP,
+            PlayerControl.SCREENSHOT,
+            PlayerControl.BACKGROUND_PLAY,
+            PlayerControl.LOOP,
+            PlayerControl.SHUFFLE,
+            PlayerControl.SLEEP_TIMER,
+        )
+
+        val customizableControls: Set<PlayerControl> =
+            (topRightControls + bottomLeftControls).toSet()
+
+        fun defaultEntries(): List<PlayerControlLayoutEntry> = buildList {
+            addAll(
+                topRightControls.map { control ->
+                    PlayerControlLayoutEntry(
+                        control = control,
+                        zone = PlayerControlZone.TOP_RIGHT,
+                    )
+                },
+            )
+            addAll(
+                bottomLeftControls.map { control ->
+                    PlayerControlLayoutEntry(
+                        control = control,
+                        zone = PlayerControlZone.BOTTOM_LEFT,
+                    )
+                },
+            )
+        }
+
+        private fun normalizeEntries(entries: List<PlayerControlLayoutEntry>): List<PlayerControlLayoutEntry> {
+            val seenControls = mutableSetOf<PlayerControl>()
+            val normalizedEntries = entries
+                .filter { it.control in customizableControls }
+                .filter { seenControls.add(it.control) }
+                .toMutableList()
+
+            defaultEntries().forEach { defaultEntry ->
+                if (defaultEntry.control in seenControls) return@forEach
+                normalizedEntries.add(defaultEntry)
+            }
+            return normalizedEntries
+        }
+    }
+}
+
+object PlayerControlsLayoutSerializer : KSerializer<PlayerControlsLayout> {
+    private val entriesSerializer = ListSerializer(PlayerControlLayoutEntry.serializer())
+
+    override val descriptor: SerialDescriptor = buildClassSerialDescriptor("one.only.player.core.model.PlayerControlsLayout") {
+        element("entries", entriesSerializer.descriptor)
+    }
+
+    override fun serialize(
+        encoder: Encoder,
+        value: PlayerControlsLayout,
+    ) {
+        encoder.encodeStructure(descriptor) {
+            encodeSerializableElement(
+                descriptor = descriptor,
+                index = 0,
+                serializer = entriesSerializer,
+                value = value.entries,
+            )
+        }
+    }
+
+    override fun deserialize(decoder: Decoder): PlayerControlsLayout {
+        var entries = PlayerControlsLayout.defaultEntries()
+
+        decoder.decodeStructure(descriptor) {
+            while (true) {
+                when (val index = decodeElementIndex(descriptor)) {
+                    CompositeDecoder.DECODE_DONE -> break
+                    0 -> entries = decodeSerializableElement(
+                        descriptor = descriptor,
+                        index = index,
+                        deserializer = entriesSerializer,
+                    )
+                }
+            }
+        }
+
+        return PlayerControlsLayout(entries)
+    }
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerControlsStyle.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerControlsStyle.kt
new file mode 100644
index 000000000..d7c7ed33d
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerControlsStyle.kt
@@ -0,0 +1,10 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class PlayerControlsStyle {
+    MODERN,
+    LEGACY,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerIconStyle.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerIconStyle.kt
new file mode 100644
index 000000000..43a74196a
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerIconStyle.kt
@@ -0,0 +1,11 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class PlayerIconStyle {
+    TONAL,
+    CLASSIC,
+    TRANSLUCENT,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerPreferences.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerPreferences.kt
new file mode 100644
index 000000000..963a55ec3
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/PlayerPreferences.kt
@@ -0,0 +1,183 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class PlayerPreferences(
+    val resume: Resume = Resume.YES,
+    val shouldRememberPlayerBrightness: Boolean = false,
+    val playerBrightness: Float = 0.5f,
+    val minDurationForFastSeek: Long = 120000L,
+    val shouldRememberSelections: Boolean = true,
+    val playerScreenOrientation: ScreenOrientation = ScreenOrientation.VIDEO_ORIENTATION,
+    val shouldRememberPlayerScreenOrientation: Boolean = false,
+    val lastPlayerScreenOrientation: LastPlayerScreenOrientation? = null,
+    val playerVideoZoom: VideoContentScale = VideoContentScale.BEST_FIT,
+    val defaultPlaybackSpeed: Float = 1.0f,
+    val shouldApplyVideoFilters: Boolean = false,
+    val isVideoBrightnessFilterEnabled: Boolean = false,
+    val videoBrightness: Float = DEFAULT_VIDEO_BRIGHTNESS,
+    val isVideoContrastFilterEnabled: Boolean = false,
+    val videoContrast: Float = DEFAULT_VIDEO_CONTRAST,
+    val isVideoSaturationFilterEnabled: Boolean = false,
+    val videoSaturation: Float = DEFAULT_VIDEO_SATURATION,
+    val isVideoHueFilterEnabled: Boolean = false,
+    val videoHue: Float = DEFAULT_VIDEO_HUE,
+    val isVideoGammaFilterEnabled: Boolean = false,
+    val videoGamma: Float = DEFAULT_VIDEO_GAMMA,
+    val isVideoSharpeningFilterEnabled: Boolean = false,
+    val videoSharpening: Float = DEFAULT_VIDEO_SHARPENING,
+    val shouldAutoPlay: Boolean = true,
+    val shouldAutoEnterPip: Boolean = true,
+    val shouldAutoPlayInBackground: Boolean = false,
+    val loopMode: LoopMode = LoopMode.OFF,
+    val isAmbienceModeEnabled: Boolean = false,
+    val statisticsPage: Int = 0,
+
+    // 手势控制
+    @Deprecated(message = "Use individual isVolumeSwipeGestureEnabled and isBrightnessSwipeGestureEnabled instead")
+    val shouldUseSwipeControls: Boolean = true,
+    val isVolumeSwipeGestureEnabled: Boolean = true,
+    val isBrightnessSwipeGestureEnabled: Boolean = true,
+    val shouldUseSeekControls: Boolean = true,
+    val shouldUseZoomControls: Boolean = true,
+    val isPanGestureEnabled: Boolean = false,
+    val doubleTapGesture: DoubleTapGesture = DoubleTapGesture.BOTH,
+    val shouldUseLongPressControls: Boolean = false,
+    val shouldUseLongPressVariableSpeed: Boolean = false,
+    val isDebugLongPressOverlayVisible: Boolean = false,
+    val longPressControlsSpeed: Float = DEFAULT_LONG_PRESS_CONTROLS_SPEED,
+    val seekIncrement: Int = DEFAULT_SEEK_INCREMENT,
+    val seekSensitivity: Float = DEFAULT_SEEK_SENSITIVITY,
+    val volumeGestureSensitivity: Float = DEFAULT_VOLUME_GESTURE_SENSITIVITY,
+    val brightnessGestureSensitivity: Float = DEFAULT_BRIGHTNESS_GESTURE_SENSITIVITY,
+
+    // 播放器界面
+    val controllerAutoHideTimeout: Int = DEFAULT_CONTROLLER_AUTO_HIDE_TIMEOUT,
+    val controlsStyle: PlayerControlsStyle = PlayerControlsStyle.MODERN,
+    val controlButtonsPosition: ControlButtonsPosition = ControlButtonsPosition.LEFT,
+    val playerControlsLayout: PlayerControlsLayout = PlayerControlsLayout(),
+    val hiddenPlayerControls: Set<PlayerControl> = emptySet(),
+    val shouldHidePlayerButtonsBackground: Boolean = false,
+    val shouldHidePlayerControlLabels: Boolean = false,
+    val playerIconStyle: PlayerIconStyle = PlayerIconStyle.TONAL,
+
+    // 音频偏好
+    val preferredAudioLanguage: String = "",
+    val shouldPauseOnHeadsetDisconnect: Boolean = true,
+    val shouldRequireAudioFocus: Boolean = true,
+    val shouldShowSystemVolumePanel: Boolean = true,
+    val isVolumeBoostEnabled: Boolean = false,
+    val shouldRememberPlayerVolume: Boolean = false,
+    val playerVolumePercentage: Int = DEFAULT_PLAYER_VOLUME_PERCENTAGE,
+    val maxInitialPlayerVolumePercentage: Int = DEFAULT_MAX_INITIAL_PLAYER_VOLUME_PERCENTAGE,
+    val isVolumeNormalizationEnabled: Boolean = false,
+
+    // 字幕偏好
+    val isSubtitleAutoLoadEnabled: Boolean = true,
+    val shouldUseSystemCaptionStyle: Boolean = false,
+    val preferredSubtitleLanguage: String = "",
+    val subtitleTextEncoding: String = "",
+    val subtitleTextSize: Int = DEFAULT_SUBTITLE_TEXT_SIZE,
+    val shouldShowSubtitleBackground: Boolean = false,
+    val subtitleFont: Font = Font.DEFAULT,
+    val shouldUseBoldSubtitleText: Boolean = true,
+    val subtitleColor: SubtitleColor = SubtitleColor.WHITE,
+    val subtitleEdgeStyle: SubtitleEdgeStyle = SubtitleEdgeStyle.DROP_SHADOW,
+    val subtitleBottomPaddingFraction: Float = DEFAULT_SUBTITLE_BOTTOM_PADDING_FRACTION,
+    val shouldApplyEmbeddedStyles: Boolean = true,
+
+    // 解码偏好
+    val decoderPriority: DecoderPriority = DecoderPriority.AUTOMATIC,
+) {
+
+    companion object {
+        const val DEFAULT_SEEK_INCREMENT = 10
+        const val DEFAULT_SEEK_SENSITIVITY = 0.50f
+        const val DEFAULT_VOLUME_GESTURE_SENSITIVITY = 0.50f
+        const val DEFAULT_BRIGHTNESS_GESTURE_SENSITIVITY = 0.50f
+        const val DEFAULT_LONG_PRESS_CONTROLS_SPEED = 2.0f
+        const val DEFAULT_VIDEO_BRIGHTNESS = 0f
+        const val MIN_VIDEO_BRIGHTNESS = -1f
+        const val MAX_VIDEO_BRIGHTNESS = 1f
+        const val DEFAULT_VIDEO_CONTRAST = 0f
+        const val MIN_VIDEO_CONTRAST = -1f
+        const val MAX_VIDEO_CONTRAST = 1f
+        const val DEFAULT_VIDEO_SATURATION = 0f
+        const val MIN_VIDEO_SATURATION = -100f
+        const val MAX_VIDEO_SATURATION = 100f
+        const val DEFAULT_VIDEO_HUE = 0f
+        const val MIN_VIDEO_HUE = -180f
+        const val MAX_VIDEO_HUE = 180f
+        const val DEFAULT_VIDEO_GAMMA = 1f
+        const val MIN_VIDEO_GAMMA = 0.1f
+        const val MAX_VIDEO_GAMMA = 3f
+        const val DEFAULT_VIDEO_SHARPENING = 0f
+        const val MAX_VIDEO_SHARPENING = 1f
+        const val MIN_LONG_PRESS_CONTROLS_SPEED = 0.2f
+        const val MAX_LONG_PRESS_CONTROLS_SPEED = 4.0f
+        const val DEFAULT_SUBTITLE_TEXT_SIZE = 20
+        const val DEFAULT_SUBTITLE_BOTTOM_PADDING_FRACTION = 0.08f
+        const val MIN_SUBTITLE_BOTTOM_PADDING_FRACTION = 0f
+        const val MAX_SUBTITLE_BOTTOM_PADDING_FRACTION = 0.4f
+        const val DEFAULT_CONTROLLER_AUTO_HIDE_TIMEOUT = 4
+        const val DEFAULT_PLAYER_VOLUME_PERCENTAGE = 100
+        const val MAX_PLAYER_VOLUME_PERCENTAGE = 200
+        const val DEFAULT_MAX_INITIAL_PLAYER_VOLUME_PERCENTAGE = MAX_PLAYER_VOLUME_PERCENTAGE
+        const val MIN_INITIAL_PLAYER_VOLUME_PERCENTAGE = 10
+        const val MAX_INITIAL_PLAYER_VOLUME_PERCENTAGE = MAX_PLAYER_VOLUME_PERCENTAGE
+        const val MAX_SEEK_INCREMENT = 120
+    }
+}
+
+fun PlayerPreferences.withSubtitleStyleFrom(preferences: PlayerPreferences): PlayerPreferences = copy(
+    shouldUseBoldSubtitleText = preferences.shouldUseBoldSubtitleText,
+    subtitleTextSize = preferences.subtitleTextSize,
+    shouldShowSubtitleBackground = preferences.shouldShowSubtitleBackground,
+    subtitleColor = preferences.subtitleColor,
+    subtitleEdgeStyle = preferences.subtitleEdgeStyle,
+    subtitleBottomPaddingFraction = preferences.subtitleBottomPaddingFraction,
+)
+
+fun PlayerPreferences.withVideoFiltersFrom(preferences: PlayerPreferences): PlayerPreferences = copy(
+    shouldApplyVideoFilters = preferences.shouldApplyVideoFilters,
+    isAmbienceModeEnabled = preferences.isAmbienceModeEnabled,
+    isVideoBrightnessFilterEnabled = preferences.isVideoBrightnessFilterEnabled,
+    videoBrightness = preferences.videoBrightness,
+    isVideoContrastFilterEnabled = preferences.isVideoContrastFilterEnabled,
+    videoContrast = preferences.videoContrast,
+    isVideoSaturationFilterEnabled = preferences.isVideoSaturationFilterEnabled,
+    videoSaturation = preferences.videoSaturation,
+    isVideoHueFilterEnabled = preferences.isVideoHueFilterEnabled,
+    videoHue = preferences.videoHue,
+    isVideoGammaFilterEnabled = preferences.isVideoGammaFilterEnabled,
+    videoGamma = preferences.videoGamma,
+    isVideoSharpeningFilterEnabled = preferences.isVideoSharpeningFilterEnabled,
+    videoSharpening = preferences.videoSharpening,
+)
+
+@Serializable
+@Suppress("MagicNumber")
+enum class PlayerControl {
+    BACK,
+    PLAYLIST,
+    PLAYBACK_SPEED,
+    AUDIO,
+    SUBTITLE,
+    PREVIOUS,
+    PLAY_PAUSE,
+    NEXT,
+    LOCK,
+    SCALE,
+    DECODER,
+    AMBIENCE_MODE,
+    VIDEO_FILTERS,
+    PIP,
+    SCREENSHOT,
+    BACKGROUND_PLAY,
+    LOOP,
+    SHUFFLE,
+    SLEEP_TIMER,
+    ROTATE,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/RemoteFile.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/RemoteFile.kt
new file mode 100644
index 000000000..e85c216b8
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/RemoteFile.kt
@@ -0,0 +1,10 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+data class RemoteFile(
+    val name: String,
+    val path: String,
+    val isDirectory: Boolean,
+    val size: Long = 0,
+    val contentType: String = "",
+)
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/RemoteServer.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/RemoteServer.kt
new file mode 100644
index 000000000..ad5a27c10
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/RemoteServer.kt
@@ -0,0 +1,22 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+data class RemoteServer(
+    val id: Long = 0,
+    val name: String,
+    val protocol: ServerProtocol,
+    val host: String,
+    val port: Int? = null,
+    val path: String = "/",
+    val username: String = "",
+    val password: String = "",
+    val isProxyEnabled: Boolean = false,
+    val proxyHost: String = "",
+    val proxyPort: Int? = null,
+)
+
+enum class ServerProtocol {
+    WEBDAV,
+    SMB,
+    FTP,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Resume.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Resume.kt
new file mode 100644
index 000000000..bc332b927
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Resume.kt
@@ -0,0 +1,10 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class Resume {
+    YES,
+    NO,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ScreenOrientation.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ScreenOrientation.kt
new file mode 100644
index 000000000..16515b3e0
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ScreenOrientation.kt
@@ -0,0 +1,20 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class ScreenOrientation {
+    AUTOMATIC,
+    LANDSCAPE,
+    LANDSCAPE_REVERSE,
+    LANDSCAPE_AUTO,
+    PORTRAIT,
+    VIDEO_ORIENTATION,
+}
+
+@Serializable
+enum class LastPlayerScreenOrientation {
+    PORTRAIT,
+    LANDSCAPE,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SearchHistory.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SearchHistory.kt
new file mode 100644
index 000000000..111b64c8b
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SearchHistory.kt
@@ -0,0 +1,23 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class SearchHistory(
+    val queries: List<String> = emptyList(),
+) {
+    companion object {
+        const val MAX_HISTORY_SIZE = 5
+    }
+
+    fun addQuery(query: String): SearchHistory {
+        if (query.isBlank()) return this
+        val normalizedQuery = query.trim()
+        val updatedQueries = listOf(normalizedQuery) + queries.filter { it != normalizedQuery }
+        return copy(queries = updatedQueries.take(MAX_HISTORY_SIZE))
+    }
+
+    fun removeQuery(query: String): SearchHistory = copy(queries = queries.filter { it != query })
+
+    fun clear(): SearchHistory = copy(queries = emptyList())
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SettingsBackup.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SettingsBackup.kt
new file mode 100644
index 000000000..a2746d37d
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SettingsBackup.kt
@@ -0,0 +1,15 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class SettingsBackup(
+    val version: Int = CURRENT_VERSION,
+    val applicationPreferences: ApplicationPreferences = ApplicationPreferences(),
+    val playerPreferences: PlayerPreferences = PlayerPreferences(),
+) {
+    companion object {
+        const val CURRENT_VERSION = 2
+    }
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Sort.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Sort.kt
new file mode 100644
index 000000000..0cd4d9594
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Sort.kt
@@ -0,0 +1,154 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+import kotlin.comparisons.reversed as kotlinReversed
+
+@Serializable
+data class Sort(
+    val by: By,
+    val order: Order,
+) {
+    @Serializable
+    enum class By {
+        TITLE,
+        LENGTH,
+        PATH,
+        SIZE,
+        DATE,
+    }
+
+    @Serializable
+    enum class Order {
+        ASCENDING,
+        DESCENDING,
+    }
+
+    private val stringComparator = Comparator<String> { str1, str2 ->
+        var str1Marker = 0
+        var str2Marker = 0
+        val str1Length = str1.length
+        val str2Length = str2.length
+
+        while (str1Marker < str1Length && str2Marker < str2Length) {
+            val thisChunk = getChunk(str1, str1Length, str1Marker)
+            str1Marker += thisChunk.length
+
+            val thatChunk = getChunk(str2, str2Length, str2Marker)
+            str2Marker += thatChunk.length
+
+            val result: Int
+            if (thisChunk[0].isDigit() && thatChunk[0].isDigit()) {
+                val thisChunkLength = thisChunk.length
+                val lengthDiff = thisChunkLength - thatChunk.length
+                if (lengthDiff == 0) {
+                    for (i in 0 until thisChunkLength) {
+                        val charDiff = thisChunk[i] - thatChunk[i]
+                        if (charDiff != 0) {
+                            return@Comparator charDiff
+                        }
+                    }
+                    result = 0
+                } else {
+                    result = lengthDiff
+                }
+            } else {
+                result = thisChunk.compareTo(thatChunk)
+            }
+
+            if (result != 0) {
+                return@Comparator result
+            }
+        }
+
+        return@Comparator str1Length - str2Length
+    }
+
+    fun videoComparator(): Comparator<Video> {
+        val videoTitleComparator: Comparator<Video> = Comparator { video1, video2 ->
+            return@Comparator stringComparator.compare(
+                video1.displayName.lowercase(),
+                video2.displayName.lowercase(),
+            )
+        }
+
+        val videoPathComparator: Comparator<Video> = Comparator { video1, video2 ->
+            return@Comparator stringComparator.compare(
+                video1.path.lowercase(),
+                video2.path.lowercase(),
+            )
+        }
+
+        val comparator = when (by) {
+            By.TITLE -> videoTitleComparator
+            By.LENGTH -> compareBy<Video> { it.duration }.then(videoTitleComparator)
+            By.PATH -> videoPathComparator
+            By.SIZE -> compareBy<Video> { it.size }.then(videoTitleComparator)
+            By.DATE -> compareBy<Video> { it.dateModified }.then(videoTitleComparator)
+        }
+
+        return when (order) {
+            Order.ASCENDING -> comparator
+            Order.DESCENDING -> comparator.reversedCompat()
+        }
+    }
+
+    fun folderComparator(): Comparator<Folder> {
+        val folderNameComparator: Comparator<Folder> = Comparator { folder1, folder2 ->
+            return@Comparator stringComparator.compare(
+                folder1.name.lowercase(),
+                folder2.name.lowercase(),
+            )
+        }
+
+        val folderPathComparator: Comparator<Folder> = Comparator { folder1, folder2 ->
+            return@Comparator stringComparator.compare(
+                folder1.path.lowercase(),
+                folder2.path.lowercase(),
+            )
+        }
+
+        val comparator = when (by) {
+            By.TITLE -> folderNameComparator
+            By.LENGTH -> compareBy<Folder> { it.mediaList.size }.then(folderNameComparator)
+            By.PATH -> folderPathComparator
+            By.SIZE -> compareBy<Folder> { it.mediaSize }.then(folderNameComparator)
+            By.DATE -> compareBy<Folder> { it.dateModified }.then(folderNameComparator)
+        }
+
+        return when (order) {
+            Order.ASCENDING -> comparator
+            Order.DESCENDING -> comparator.reversedCompat()
+        }
+    }
+
+    private fun getChunk(string: String, length: Int, marker: Int): String {
+        var current = marker
+        val chunk = StringBuilder()
+        var c = string[current]
+        chunk.append(c)
+        current++
+        if (c.isDigit()) {
+            while (current < length) {
+                c = string[current]
+                if (!c.isDigit()) {
+                    break
+                }
+                chunk.append(c)
+                current++
+            }
+        } else {
+            while (current < length) {
+                c = string[current]
+                if (c.isDigit()) {
+                    break
+                }
+                chunk.append(c)
+                current++
+            }
+        }
+        return chunk.toString()
+    }
+}
+
+fun <T> Comparator<T>.reversedCompat(): Comparator<T> = kotlinReversed()
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SubtitleStreamInfo.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SubtitleStreamInfo.kt
new file mode 100644
index 000000000..c0b82eada
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SubtitleStreamInfo.kt
@@ -0,0 +1,12 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import java.io.Serializable
+
+data class SubtitleStreamInfo(
+    val index: Int,
+    val title: String?,
+    val codecName: String,
+    val language: String?,
+    val disposition: Int,
+) : Serializable
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SubtitleStyle.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SubtitleStyle.kt
new file mode 100644
index 000000000..0b7127951
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/SubtitleStyle.kt
@@ -0,0 +1,19 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class SubtitleColor {
+    WHITE,
+    YELLOW,
+    CYAN,
+    GREEN,
+}
+
+@Serializable
+enum class SubtitleEdgeStyle {
+    NONE,
+    OUTLINE,
+    DROP_SHADOW,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ThemeConfig.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ThemeConfig.kt
new file mode 100644
index 000000000..30b933326
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ThemeConfig.kt
@@ -0,0 +1,11 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class ThemeConfig {
+    SYSTEM,
+    OFF,
+    ON,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ThumbnailGenerationStrategy.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ThumbnailGenerationStrategy.kt
new file mode 100644
index 000000000..6f77ae631
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/ThumbnailGenerationStrategy.kt
@@ -0,0 +1,11 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class ThumbnailGenerationStrategy {
+    FIRST_FRAME,
+    FRAME_AT_PERCENTAGE,
+    HYBRID,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Video.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Video.kt
new file mode 100644
index 000000000..ec78fc516
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/Video.kt
@@ -0,0 +1,50 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import java.io.Serializable
+import java.util.Date
+
+data class Video(
+    val id: Long,
+    val path: String,
+    val parentPath: String = "",
+    val duration: Long,
+    val uriString: String,
+    val nameWithExtension: String,
+    val width: Int,
+    val height: Int,
+    val size: Long,
+    val isInRecycleBin: Boolean = false,
+    val playbackPosition: Long = 200,
+    val dateModified: Long = 0,
+    val formattedDuration: String = "",
+    val formattedFileSize: String = "",
+    val format: String? = null,
+    val lastPlayedAt: Date? = null,
+    val videoStream: VideoStreamInfo? = null,
+    val audioStreams: List<AudioStreamInfo> = emptyList(),
+    val subtitleStreams: List<SubtitleStreamInfo> = emptyList(),
+) : Serializable {
+
+    val displayName: String = nameWithExtension.substringBeforeLast(".")
+    val playedPercentage: Float = (playbackPosition.toFloat() / duration.toFloat()).takeIf { playbackPosition >= 0 } ?: 1f
+
+    companion object {
+        val sample = Video(
+            id = 8,
+            path = "/storage/emulated/0/Movies/Sample/Sample Video 08.mp4",
+            parentPath = "/storage/emulated/0/Movies/Sample",
+            uriString = "",
+            nameWithExtension = "Sample Video 08.mp4",
+            duration = 1000,
+            width = 1920,
+            height = 1080,
+            size = 1000,
+            formattedDuration = "29.36",
+            formattedFileSize = "320KB",
+            playbackPosition = 200,
+        )
+    }
+}
+
+fun List<Video>.recentPlayed(): Video? = filter { it.lastPlayedAt != null }.sortedByDescending { it.lastPlayedAt?.time }.firstOrNull()
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/VideoContentScale.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/VideoContentScale.kt
new file mode 100644
index 000000000..f5230deb3
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/VideoContentScale.kt
@@ -0,0 +1,12 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class VideoContentScale {
+    BEST_FIT,
+    STRETCH,
+    CROP,
+    HUNDRED_PERCENT,
+}
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/VideoStreamInfo.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/VideoStreamInfo.kt
new file mode 100644
index 000000000..7f9bd9ca5
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/model/VideoStreamInfo.kt
@@ -0,0 +1,16 @@
+package app.gyrolet.mpvrx.exoplayer.core.model
+
+import java.io.Serializable
+
+data class VideoStreamInfo(
+    val index: Int,
+    val title: String?,
+    val codecName: String,
+    val language: String?,
+    val disposition: Int,
+    val bitRate: Long,
+    val frameRate: Double,
+    val frameWidth: Int,
+    val frameHeight: Int,
+) : Serializable
+
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/Buttons.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/Buttons.kt
new file mode 100644
index 000000000..0a18cb210
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/Buttons.kt
@@ -0,0 +1,38 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.gyrolet.mpvrx.R
+
+@Composable
+fun DoneButton(
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    isEnabled: Boolean = true,
+) {
+    TextButton(
+        enabled = isEnabled,
+        onClick = onClick,
+        modifier = modifier,
+    ) {
+        Text(text = stringResource(R.string.generic_confirm))
+    }
+}
+
+@Composable
+fun CancelButton(
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    isEnabled: Boolean = true,
+) {
+    TextButton(
+        enabled = isEnabled,
+        onClick = onClick,
+        modifier = modifier,
+    ) {
+        Text(text = stringResource(R.string.generic_cancel))
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/ClickablePreferenceItem.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/ClickablePreferenceItem.kt
new file mode 100644
index 000000000..4c66af7bf
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/ClickablePreferenceItem.kt
@@ -0,0 +1,47 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+
+@OptIn(ExperimentalFoundationApi::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun ClickablePreferenceItem(
+    title: String,
+    modifier: Modifier = Modifier,
+    description: String? = null,
+    isEnabled: Boolean = true,
+    icon: AppIcon? = null,
+    onClick: () -> Unit = {},
+    onLongClick: (() -> Unit)? = null,
+    isFirstItem: Boolean = false,
+    isLastItem: Boolean = false,
+) {
+    PreferenceItem(
+        title = title,
+        description = description,
+        icon = icon,
+        modifier = modifier,
+        isEnabled = isEnabled,
+        onClick = onClick,
+        onLongClick = onLongClick,
+        isFirstItem = isFirstItem,
+        isLastItem = isLastItem,
+    )
+}
+
+@Preview
+@Composable
+private fun ClickablePreferenceItemPreview() {
+    ClickablePreferenceItem(
+        title = "Title",
+        description = "Description of the preference item goes here.",
+        icon = NextIcons.DoubleTap,
+        onClick = {},
+        isEnabled = false,
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/ListItemComponent.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/ListItemComponent.kt
new file mode 100644
index 000000000..2c355526f
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/ListItemComponent.kt
@@ -0,0 +1,92 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.CornerBasedShape
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.ListItemColors
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.ListItemShapes
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.SegmentedListItem
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun NextSegmentedListItem(
+    modifier: Modifier = Modifier,
+    isSelected: Boolean = false,
+    isEnabled: Boolean = true,
+    isFirstItem: Boolean = false,
+    isLastItem: Boolean = false,
+    contentPadding: PaddingValues = PaddingValues(16.dp),
+    colors: ListItemColors = ListItemDefaults.segmentedColors(),
+    shapes: ListItemShapes = ListItemDefaults.shapes(),
+    leadingContent: @Composable (() -> Unit)? = null,
+    trailingContent: @Composable (() -> Unit)? = null,
+    overlineContent: @Composable (() -> Unit)? = null,
+    supportingContent: @Composable (() -> Unit)? = null,
+    content: @Composable () -> Unit,
+    onClick: () -> Unit = {},
+    onLongClick: (() -> Unit)? = null,
+    interactionSource: MutableInteractionSource? = null,
+) {
+    val overrideShape = MaterialTheme.shapes.large
+    SegmentedListItem(
+        modifier = modifier,
+        selected = isSelected,
+        onClick = onClick,
+        onLongClick = onLongClick,
+        enabled = isEnabled,
+        verticalAlignment = Alignment.CenterVertically,
+        shapes = remember(isFirstItem, isLastItem, shapes) {
+            val defaultBaseShape = shapes.shape
+            if (defaultBaseShape is CornerBasedShape) {
+                shapes.copy(
+                    shape = defaultBaseShape.copy(
+                        topStart = overrideShape.topStart.takeIf { isFirstItem } ?: defaultBaseShape.topStart,
+                        topEnd = overrideShape.topEnd.takeIf { isFirstItem } ?: defaultBaseShape.topEnd,
+                        bottomStart = overrideShape.bottomStart.takeIf { isLastItem } ?: defaultBaseShape.bottomStart,
+                        bottomEnd = overrideShape.bottomEnd.takeIf { isLastItem } ?: defaultBaseShape.bottomEnd,
+                    ),
+                )
+            } else {
+                shapes
+            }
+        },
+        colors = colors,
+        contentPadding = contentPadding,
+        leadingContent = leadingContent,
+        supportingContent = supportingContent,
+        trailingContent = trailingContent,
+        overlineContent = overlineContent,
+        interactionSource = interactionSource,
+        content = content,
+    )
+}
+
+@Composable
+fun ListSectionTitle(
+    modifier: Modifier = Modifier,
+    text: String,
+    contentPadding: PaddingValues = PaddingValues(
+        start = 12.dp,
+        top = 20.dp,
+        bottom = 10.dp,
+    ),
+    color: Color = MaterialTheme.colorScheme.primary,
+) {
+    Text(
+        text = text,
+        modifier = modifier.padding(contentPadding),
+        color = color,
+        style = MaterialTheme.typography.labelLarge,
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/NextDialog.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/NextDialog.kt
new file mode 100644
index 000000000..605442312
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/NextDialog.kt
@@ -0,0 +1,62 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.DialogProperties
+
+@Composable
+fun NextDialog(
+    onDismissRequest: () -> Unit,
+    title: @Composable () -> Unit,
+    content: @Composable () -> Unit,
+    modifier: Modifier = Modifier,
+    confirmButton: @Composable () -> Unit,
+    dismissButton: @Composable (() -> Unit)? = null,
+    dialogProperties: DialogProperties = NextDialogDefaults.dialogProperties,
+) {
+    val configuration = LocalConfiguration.current
+
+    AlertDialog(
+        title = title,
+        text = { Column { content() } },
+        modifier = modifier
+            .widthIn(max = configuration.screenWidthDp.dp - NextDialogDefaults.dialogMargin * 2),
+        onDismissRequest = onDismissRequest,
+        confirmButton = confirmButton,
+        dismissButton = dismissButton,
+        properties = dialogProperties,
+    )
+}
+
+@Composable
+fun NextDialogWithDoneAndCancelButtons(
+    title: String,
+    onDoneClick: () -> Unit,
+    onDismissClick: () -> Unit,
+    content: @Composable () -> Unit,
+) {
+    NextDialog(
+        title = { Text(text = title) },
+        confirmButton = { DoneButton(onClick = onDoneClick) },
+        dismissButton = { CancelButton(onClick = onDismissClick) },
+        onDismissRequest = onDismissClick,
+        content = content,
+    )
+}
+
+object NextDialogDefaults {
+    val dialogProperties: DialogProperties = DialogProperties(
+        usePlatformDefaultWidth = false,
+        dismissOnBackPress = true,
+        dismissOnClickOutside = true,
+        decorFitsSystemWindows = true,
+    )
+    val dialogMargin: Dp = 16.dp
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/NextSwitch.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/NextSwitch.kt
new file mode 100644
index 000000000..6ab6b74d0
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/NextSwitch.kt
@@ -0,0 +1,39 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Switch
+import androidx.compose.material3.SwitchDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@Composable
+fun NextSwitch(
+    isChecked: Boolean,
+    onCheckedChange: ((Boolean) -> Unit)?,
+    modifier: Modifier = Modifier,
+    isEnabled: Boolean = true,
+    checkedIcon: AppIcon = NextIcons.Check,
+) {
+    val thumbContent: (@Composable () -> Unit)? = if (isChecked) {
+        {
+            Icon(
+                imageVector = checkedIcon,
+                contentDescription = null,
+                modifier = Modifier.size(SwitchDefaults.IconSize),
+            )
+        }
+    } else {
+        null
+    }
+
+    Switch(
+        checked = isChecked,
+        onCheckedChange = onCheckedChange,
+        modifier = modifier,
+        enabled = isEnabled,
+        thumbContent = thumbContent,
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/NextTopAppBar.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/NextTopAppBar.kt
new file mode 100644
index 000000000..d3c7ad5b9
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/NextTopAppBar.kt
@@ -0,0 +1,79 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarColors
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun NextTopAppBar(
+    modifier: Modifier = Modifier,
+    title: @Composable () -> Unit,
+    navigationIcon: @Composable () -> Unit = {},
+    actions: @Composable RowScope.() -> Unit = {},
+    colors: TopAppBarColors = TopAppBarDefaults.topAppBarColors(
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+    ),
+) {
+    TopAppBar(
+        title = title,
+        navigationIcon = navigationIcon,
+        actions = actions,
+        colors = colors,
+        modifier = modifier,
+        contentPadding = PaddingValues(horizontal = 8.dp),
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
+@Composable
+fun NextTopAppBar(
+    modifier: Modifier = Modifier,
+    title: String,
+    fontWeight: FontWeight? = null,
+    onTitleLongClick: (() -> Unit)? = null,
+    navigationIcon: @Composable () -> Unit = {},
+    actions: @Composable RowScope.() -> Unit = {},
+    colors: TopAppBarColors = TopAppBarDefaults.topAppBarColors(
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+    ),
+) {
+    NextTopAppBar(
+        title = {
+            Text(
+                text = title,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                fontWeight = fontWeight,
+                modifier = if (onTitleLongClick != null) {
+                    Modifier.combinedClickable(
+                        interactionSource = remember { MutableInteractionSource() },
+                        indication = null,
+                        onLongClick = onTitleLongClick,
+                        onClick = {},
+                    )
+                } else {
+                    Modifier
+                },
+            )
+        },
+        navigationIcon = navigationIcon,
+        actions = actions,
+        colors = colors,
+        modifier = modifier,
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/OptionsDialog.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/OptionsDialog.kt
new file mode 100644
index 000000000..162c5ef15
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/OptionsDialog.kt
@@ -0,0 +1,38 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListScope
+import androidx.compose.foundation.selection.selectableGroup
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun OptionsDialog(
+    title: String,
+    onDismissClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    options: LazyListScope.() -> Unit,
+) {
+    NextDialog(
+        modifier = modifier,
+        onDismissRequest = onDismissClick,
+        title = {
+            Text(text = title)
+        },
+        content = {
+            HorizontalDivider()
+            LazyColumn(
+                contentPadding = PaddingValues(vertical = 8.dp),
+                modifier = Modifier.selectableGroup(),
+                content = options,
+            )
+            HorizontalDivider()
+        },
+        dismissButton = { CancelButton(onClick = onDismissClick) },
+        confirmButton = { },
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceItem.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceItem.kt
new file mode 100644
index 000000000..8e48644c1
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceItem.kt
@@ -0,0 +1,174 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextDecoration
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun PreferenceItem(
+    modifier: Modifier = Modifier,
+    title: String,
+    description: String? = null,
+    icon: AppIcon? = null,
+    isEnabled: Boolean,
+    onClick: () -> Unit = {},
+    onLongClick: (() -> Unit)? = null,
+    isFirstItem: Boolean = false,
+    isLastItem: Boolean = false,
+    trailingContent: @Composable () -> Unit = {},
+) {
+    NextSegmentedListItem(
+        modifier = modifier,
+        onClick = onClick,
+        onLongClick = onLongClick,
+        isEnabled = isEnabled,
+        isFirstItem = isFirstItem,
+        isLastItem = isLastItem,
+        leadingContent = icon?.let {
+            {
+                Icon(
+                    imageVector = icon,
+                    contentDescription = null,
+                    modifier = Modifier.size(24.dp),
+                )
+            }
+        },
+        supportingContent = description?.let {
+            {
+                Text(text = description)
+            }
+        },
+        content = {
+            Text(text = title)
+        },
+        trailingContent = trailingContent,
+    )
+}
+
+@OptIn(ExperimentalFoundationApi::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun SelectablePreference(
+    title: String,
+    modifier: Modifier = Modifier,
+    description: String? = null,
+    isSelected: Boolean = false,
+    onClick: () -> Unit = {},
+    onLongClick: () -> Unit = {},
+    isFirstItem: Boolean = false,
+    isLastItem: Boolean = false,
+) {
+    NextSegmentedListItem(
+        modifier = modifier,
+        onClick = onClick,
+        onLongClick = onLongClick,
+        isFirstItem = isFirstItem,
+        isLastItem = isLastItem,
+        content = {
+            Text(
+                text = title,
+                maxLines = 1,
+                style = MaterialTheme.typography.titleMedium.copy(
+                    textDecoration = if (isSelected) TextDecoration.LineThrough else TextDecoration.None,
+                ),
+            )
+        },
+        supportingContent = {
+            description?.let {
+                Text(
+                    text = it,
+                    overflow = TextOverflow.Ellipsis,
+                    style = MaterialTheme.typography.bodyMedium.copy(
+                        textDecoration = if (isSelected) TextDecoration.LineThrough else TextDecoration.None,
+                    ),
+                )
+            }
+        },
+        trailingContent = {
+            Checkbox(
+                modifier = Modifier.semantics { contentDescription = title },
+                checked = isSelected,
+                onCheckedChange = null,
+            )
+        },
+    )
+}
+
+@OptIn(ExperimentalFoundationApi::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun SingleSelectablePreference(
+    title: String,
+    modifier: Modifier = Modifier,
+    description: String? = null,
+    isSelected: Boolean = false,
+    onClick: () -> Unit = {},
+    onLongClick: (() -> Unit)? = null,
+    isFirstItem: Boolean = false,
+    isLastItem: Boolean = false,
+) {
+    NextSegmentedListItem(
+        modifier = modifier,
+        onClick = onClick,
+        onLongClick = onLongClick,
+        isFirstItem = isFirstItem,
+        isLastItem = isLastItem,
+        content = {
+            Text(
+                text = title,
+                maxLines = 1,
+            )
+        },
+        supportingContent = {
+            description?.let {
+                Text(
+                    text = it,
+                    overflow = TextOverflow.Ellipsis,
+                )
+            }
+        },
+        leadingContent = {
+            RadioButton(
+                selected = isSelected,
+                onClick = null,
+            )
+        },
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+fun PreferenceItemPreview() {
+    PreferenceItem(
+        title = "Title",
+        description = "Description of the preference item goes here.",
+        icon = NextIcons.DoubleTap,
+        isEnabled = true,
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+fun SelectablePreferencePreview() {
+    SelectablePreference(
+        title = "Title",
+        description = "Description of the preference item goes here.",
+    )
+}
+
+internal fun Color.applyAlpha(isEnabled: Boolean): Color = if (isEnabled) this else this.copy(alpha = 0.6f)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceSlider.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceSlider.kt
new file mode 100644
index 000000000..30664f4d4
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceSlider.kt
@@ -0,0 +1,69 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun PreferenceSlider(
+    modifier: Modifier = Modifier,
+    sliderModifier: Modifier = Modifier,
+    title: String,
+    description: String? = null,
+    icon: AppIcon? = null,
+    isEnabled: Boolean = true,
+    isSliderEnabled: Boolean = isEnabled,
+    isFirstItem: Boolean = false,
+    isLastItem: Boolean = false,
+    value: Float,
+    valueRange: ClosedFloatingPointRange<Float> = 0f..1f,
+    onValueChange: (Float) -> Unit,
+    onValueChangeFinished: () -> Unit = {},
+    trailingContent: @Composable () -> Unit = {},
+) {
+    NextSegmentedListItem(
+        modifier = modifier,
+        onClick = {},
+        onLongClick = null,
+        isEnabled = isEnabled,
+        isFirstItem = isFirstItem,
+        isLastItem = isLastItem,
+        leadingContent = icon?.let {
+            {
+                Icon(
+                    imageVector = icon,
+                    contentDescription = null,
+                    modifier = Modifier.size(24.dp),
+                )
+            }
+        },
+        supportingContent = {
+            Column {
+                description?.let {
+                    Text(text = description)
+                }
+                Slider(
+                    modifier = sliderModifier.fillMaxWidth(),
+                    enabled = isSliderEnabled,
+                    value = value,
+                    valueRange = valueRange,
+                    onValueChange = onValueChange,
+                    onValueChangeFinished = onValueChangeFinished,
+                )
+            }
+        },
+        content = {
+            Text(text = title)
+        },
+        trailingContent = trailingContent,
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceSwitch.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceSwitch.kt
new file mode 100644
index 000000000..e16b5add5
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceSwitch.kt
@@ -0,0 +1,49 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+
+@Composable
+fun PreferenceSwitch(
+    title: String,
+    modifier: Modifier = Modifier,
+    description: String? = null,
+    icon: AppIcon? = null,
+    isEnabled: Boolean = true,
+    isChecked: Boolean = true,
+    onClick: (() -> Unit) = {},
+    isFirstItem: Boolean = false,
+    isLastItem: Boolean = false,
+) {
+    PreferenceItem(
+        modifier = modifier,
+        title = title,
+        description = description,
+        icon = icon,
+        isEnabled = isEnabled,
+        onClick = onClick,
+        isFirstItem = isFirstItem,
+        isLastItem = isLastItem,
+        trailingContent = {
+            NextSwitch(
+                isChecked = isChecked,
+                onCheckedChange = null,
+                isEnabled = isEnabled,
+            )
+        },
+    )
+}
+
+@Preview
+@Composable
+fun PreferenceSwitchPreview() {
+    PreferenceSwitch(
+        title = "Title",
+        description = "Description of the preference item goes here.",
+        icon = NextIcons.DoubleTap,
+        onClick = {},
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceSwitchWithDivider.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceSwitchWithDivider.kt
new file mode 100644
index 000000000..16130f874
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/PreferenceSwitchWithDivider.kt
@@ -0,0 +1,96 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.selection.toggleable
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.VerticalDivider
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+
+@Composable
+fun PreferenceSwitchWithDivider(
+    title: String = "",
+    modifier: Modifier = Modifier,
+    switchModifier: Modifier = Modifier,
+    description: String? = null,
+    icon: AppIcon? = null,
+    isEnabled: Boolean = true,
+    isChecked: Boolean = true,
+    onClick: (() -> Unit) = {},
+    onChecked: () -> Unit = {},
+    isFirstItem: Boolean = false,
+    isLastItem: Boolean = false,
+) {
+    PreferenceItem(
+        modifier = modifier,
+        title = title,
+        description = description,
+        icon = icon,
+        onClick = onClick,
+        isEnabled = isEnabled,
+        isFirstItem = isFirstItem,
+        isLastItem = isLastItem,
+        trailingContent = {
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                VerticalDivider(
+                    modifier = Modifier
+                        .padding(end = 12.dp)
+                        .height(40.dp),
+                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.3f),
+                )
+                NextSwitch(
+                    modifier = switchModifier,
+                    isChecked = isChecked,
+                    onCheckedChange = { onChecked() },
+                    isEnabled = isEnabled,
+                )
+            }
+        },
+    )
+}
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+fun PreferenceCheckbox(
+    title: String,
+    description: String? = null,
+    icon: AppIcon? = null,
+    isEnabled: Boolean = true,
+    isChecked: Boolean = true,
+    onClick: (() -> Unit) = {},
+    onLongClick: (() -> Unit) = {},
+) {
+    PreferenceItem(
+        title = title,
+        description = description,
+        icon = icon,
+        modifier = Modifier
+            .toggleable(
+                value = isChecked,
+                enabled = isEnabled,
+                onValueChange = { onClick() },
+            )
+            .combinedClickable(
+                onClick = onClick,
+                onLongClick = onLongClick,
+            ),
+        isEnabled = isEnabled,
+        trailingContent = {
+            Checkbox(
+                checked = isChecked,
+                onCheckedChange = null,
+            )
+        },
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/RadioTextButton.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/RadioTextButton.kt
new file mode 100644
index 000000000..e42756597
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/RadioTextButton.kt
@@ -0,0 +1,42 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun RadioTextButton(
+    text: String,
+    isSelected: Boolean,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = modifier
+            .fillMaxWidth()
+            .selectable(
+                selected = isSelected,
+                onClick = onClick,
+                role = Role.RadioButton,
+            )
+            .padding(12.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        RadioButton(
+            selected = isSelected,
+            onClick = null,
+        )
+        Spacer(modifier = Modifier.width(8.dp))
+        Text(text = text)
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/SubtitleStylePanel.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/SubtitleStylePanel.kt
new file mode 100644
index 000000000..0f8658ab2
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/SubtitleStylePanel.kt
@@ -0,0 +1,157 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledIconButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import kotlin.math.roundToInt
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.SubtitleColor
+import app.gyrolet.mpvrx.exoplayer.core.model.SubtitleEdgeStyle
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun SubtitleStylePanel(
+    preferences: PlayerPreferences,
+    onPreferencesChange: (PlayerPreferences) -> Unit,
+) {
+    val isEnabled = preferences.shouldUseSystemCaptionStyle.not()
+    Column(
+        verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+    ) {
+        PreferenceSwitch(
+            modifier = Modifier.testTag("switch_settings_subtitle_bold"),
+            title = stringResource(id = R.string.subtitle_text_bold),
+            description = stringResource(id = R.string.subtitle_text_bold_desc),
+            icon = NextIcons.Bold,
+            isEnabled = isEnabled,
+            isChecked = preferences.shouldUseBoldSubtitleText,
+            onClick = { onPreferencesChange(preferences.copy(shouldUseBoldSubtitleText = !preferences.shouldUseBoldSubtitleText)) },
+            isFirstItem = true,
+        )
+        PreferenceSlider(
+            modifier = Modifier.testTag("item_settings_subtitle_size"),
+            sliderModifier = Modifier.testTag("slider_settings_subtitle_size"),
+            title = stringResource(id = R.string.subtitle_text_size),
+            description = preferences.subtitleTextSize.toString(),
+            icon = NextIcons.FontSize,
+            isEnabled = isEnabled,
+            value = preferences.subtitleTextSize.toFloat(),
+            valueRange = SUBTITLE_TEXT_SIZE_RANGE,
+            onValueChange = { onPreferencesChange(preferences.copy(subtitleTextSize = it.toInt())) },
+            trailingContent = {
+                FilledIconButton(
+                    modifier = Modifier.testTag("btn_reset_settings_subtitle_size"),
+                    enabled = isEnabled,
+                    onClick = {
+                        onPreferencesChange(
+                            preferences.copy(subtitleTextSize = PlayerPreferences.DEFAULT_SUBTITLE_TEXT_SIZE),
+                        )
+                    },
+                ) {
+                    Icon(
+                        imageVector = NextIcons.History,
+                        contentDescription = stringResource(id = R.string.generic_reset),
+                    )
+                }
+            },
+        )
+        PreferenceSlider(
+            modifier = Modifier.testTag("item_settings_subtitle_bottom_padding"),
+            sliderModifier = Modifier.testTag("slider_settings_subtitle_bottom_padding"),
+            title = stringResource(id = R.string.subtitle_position),
+            description = "${(preferences.subtitleBottomPaddingFraction * 100).roundToInt()}%",
+            icon = NextIcons.Length,
+            isEnabled = isEnabled,
+            value = preferences.subtitleBottomPaddingFraction,
+            valueRange = SUBTITLE_POSITION_RANGE,
+            onValueChange = { onPreferencesChange(preferences.copy(subtitleBottomPaddingFraction = it)) },
+            trailingContent = {
+                FilledIconButton(
+                    modifier = Modifier.testTag("btn_reset_settings_subtitle_bottom_padding"),
+                    enabled = isEnabled,
+                    onClick = {
+                        onPreferencesChange(
+                            preferences.copy(
+                                subtitleBottomPaddingFraction = PlayerPreferences.DEFAULT_SUBTITLE_BOTTOM_PADDING_FRACTION,
+                            ),
+                        )
+                    },
+                ) {
+                    Icon(
+                        imageVector = NextIcons.History,
+                        contentDescription = stringResource(id = R.string.generic_reset),
+                    )
+                }
+            },
+        )
+        PreferenceSwitch(
+            modifier = Modifier.testTag("switch_settings_subtitle_background"),
+            title = stringResource(id = R.string.subtitle_background),
+            description = stringResource(id = R.string.subtitle_background_desc),
+            icon = NextIcons.Background,
+            isEnabled = isEnabled,
+            isChecked = preferences.shouldShowSubtitleBackground,
+            onClick = { onPreferencesChange(preferences.copy(shouldShowSubtitleBackground = !preferences.shouldShowSubtitleBackground)) },
+        )
+        ClickablePreferenceItem(
+            modifier = Modifier.testTag("item_settings_subtitle_color"),
+            title = stringResource(id = R.string.subtitle_text_color),
+            description = preferences.subtitleColor.displayName(),
+            icon = NextIcons.Appearance,
+            isEnabled = isEnabled,
+            onClick = { onPreferencesChange(preferences.copy(subtitleColor = preferences.subtitleColor.next())) },
+        )
+        ClickablePreferenceItem(
+            modifier = Modifier.testTag("item_settings_subtitle_edge_style"),
+            title = stringResource(id = R.string.subtitle_edge_style),
+            description = preferences.subtitleEdgeStyle.displayName(),
+            icon = NextIcons.Style,
+            isEnabled = isEnabled,
+            onClick = { onPreferencesChange(preferences.copy(subtitleEdgeStyle = preferences.subtitleEdgeStyle.next())) },
+            isLastItem = true,
+        )
+    }
+}
+
+@Composable
+private fun SubtitleColor.displayName(): String = when (this) {
+    SubtitleColor.WHITE -> stringResource(R.string.subtitle_color_white)
+    SubtitleColor.YELLOW -> stringResource(R.string.subtitle_color_yellow)
+    SubtitleColor.CYAN -> stringResource(R.string.subtitle_color_cyan)
+    SubtitleColor.GREEN -> stringResource(R.string.subtitle_color_green)
+}
+
+private fun SubtitleColor.next(): SubtitleColor = when (this) {
+    SubtitleColor.WHITE -> SubtitleColor.YELLOW
+    SubtitleColor.YELLOW -> SubtitleColor.CYAN
+    SubtitleColor.CYAN -> SubtitleColor.GREEN
+    SubtitleColor.GREEN -> SubtitleColor.WHITE
+}
+
+@Composable
+private fun SubtitleEdgeStyle.displayName(): String = when (this) {
+    SubtitleEdgeStyle.NONE -> stringResource(R.string.subtitle_edge_none)
+    SubtitleEdgeStyle.OUTLINE -> stringResource(R.string.subtitle_edge_outline)
+    SubtitleEdgeStyle.DROP_SHADOW -> stringResource(R.string.subtitle_edge_shadow)
+}
+
+private fun SubtitleEdgeStyle.next(): SubtitleEdgeStyle = when (this) {
+    SubtitleEdgeStyle.NONE -> SubtitleEdgeStyle.OUTLINE
+    SubtitleEdgeStyle.OUTLINE -> SubtitleEdgeStyle.DROP_SHADOW
+    SubtitleEdgeStyle.DROP_SHADOW -> SubtitleEdgeStyle.NONE
+}
+
+private val SUBTITLE_TEXT_SIZE_RANGE = 10f..60f
+private val SUBTITLE_POSITION_RANGE = PlayerPreferences.MIN_SUBTITLE_BOTTOM_PADDING_FRACTION..PlayerPreferences.MAX_SUBTITLE_BOTTOM_PADDING_FRACTION
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/VideoFiltersPanel.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/VideoFiltersPanel.kt
new file mode 100644
index 000000000..e4b8fcecf
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/components/VideoFiltersPanel.kt
@@ -0,0 +1,415 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.components
+
+import android.content.res.Configuration
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+
+@Composable
+fun VideoFiltersPanel(
+    preferences: PlayerPreferences,
+    onDismissRequest: () -> Unit,
+    onPreviewPreferences: (PlayerPreferences) -> Unit,
+    onConfirmPreferences: (PlayerPreferences) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val configuration = LocalConfiguration.current
+    val isLandscape = configuration.orientation == Configuration.ORIENTATION_LANDSCAPE
+
+    VideoFiltersEditor(
+        preferences = preferences,
+        onDismissRequest = onDismissRequest,
+        onPreviewPreferences = onPreviewPreferences,
+        onConfirmPreferences = onConfirmPreferences,
+    ) { draftPreferences, updateDraft, resetFilters, restoreAndDismiss, confirmAndDismiss ->
+        Column(
+            modifier = modifier
+                .fillMaxWidth()
+                .padding(horizontal = 24.dp)
+                .padding(bottom = 24.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            if (isLandscape) {
+                LandscapeVideoFiltersContent(
+                    modifier = Modifier.weight(1f),
+                    preferences = draftPreferences,
+                    onUpdatePreferences = updateDraft,
+                )
+            } else {
+                PortraitVideoFiltersContent(
+                    modifier = Modifier.weight(1f),
+                    preferences = draftPreferences,
+                    onUpdatePreferences = updateDraft,
+                )
+            }
+
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End),
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Spacer(modifier = Modifier.weight(1f))
+                CancelButton(
+                    modifier = Modifier.testTag("btn_cancel_video_filters"),
+                    onClick = restoreAndDismiss,
+                )
+                DoneButton(
+                    modifier = Modifier.testTag("btn_done_video_filters"),
+                    onClick = confirmAndDismiss,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun VideoFiltersEditor(
+    preferences: PlayerPreferences,
+    onDismissRequest: () -> Unit,
+    onPreviewPreferences: (PlayerPreferences) -> Unit,
+    onConfirmPreferences: (PlayerPreferences) -> Unit,
+    content: @Composable (
+        draftPreferences: PlayerPreferences,
+        updateDraft: (((PlayerPreferences) -> PlayerPreferences) -> Unit),
+        resetFilters: () -> Unit,
+        restoreAndDismiss: () -> Unit,
+        confirmAndDismiss: () -> Unit,
+    ) -> Unit,
+) {
+    val initialPreferences = remember(preferences) { preferences }
+    var draftPreferences by remember(preferences) { mutableStateOf(preferences) }
+    val updateDraft = { transform: (PlayerPreferences) -> PlayerPreferences ->
+        val updatedPreferences = transform(draftPreferences)
+        draftPreferences = updatedPreferences
+        onPreviewPreferences(updatedPreferences)
+    }
+    val restoreAndDismiss = {
+        onPreviewPreferences(initialPreferences)
+        onDismissRequest()
+    }
+    val confirmAndDismiss = {
+        onConfirmPreferences(draftPreferences)
+        onDismissRequest()
+    }
+    val resetFilters = {
+        updateDraft {
+            it.copy(
+                shouldApplyVideoFilters = false,
+                isVideoBrightnessFilterEnabled = false,
+                videoBrightness = PlayerPreferences.DEFAULT_VIDEO_BRIGHTNESS,
+                isVideoContrastFilterEnabled = false,
+                videoContrast = PlayerPreferences.DEFAULT_VIDEO_CONTRAST,
+                isVideoSaturationFilterEnabled = false,
+                videoSaturation = PlayerPreferences.DEFAULT_VIDEO_SATURATION,
+                isVideoHueFilterEnabled = false,
+                videoHue = PlayerPreferences.DEFAULT_VIDEO_HUE,
+                isVideoGammaFilterEnabled = false,
+                videoGamma = PlayerPreferences.DEFAULT_VIDEO_GAMMA,
+                isVideoSharpeningFilterEnabled = false,
+                videoSharpening = PlayerPreferences.DEFAULT_VIDEO_SHARPENING,
+            )
+        }
+    }
+
+    content(
+        draftPreferences,
+        updateDraft,
+        resetFilters,
+        restoreAndDismiss,
+        confirmAndDismiss,
+    )
+}
+
+@Composable
+private fun PortraitVideoFiltersContent(
+    preferences: PlayerPreferences,
+    onUpdatePreferences: ((PlayerPreferences) -> PlayerPreferences) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val sliderSpecs = videoFilterSliderSpecs(preferences, onUpdatePreferences)
+
+    Column(
+        modifier = modifier
+            .fillMaxWidth()
+            .verticalScroll(rememberScrollState()),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        VideoFiltersSwitch(
+            preferences = preferences,
+            onUpdatePreferences = onUpdatePreferences,
+        )
+        sliderSpecs.forEach { spec ->
+            VideoFilterSlider(spec)
+        }
+    }
+}
+
+@Composable
+private fun LandscapeVideoFiltersContent(
+    preferences: PlayerPreferences,
+    onUpdatePreferences: ((PlayerPreferences) -> PlayerPreferences) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val sliderSpecs = videoFilterSliderSpecs(preferences, onUpdatePreferences)
+
+    Column(
+        modifier = modifier
+            .fillMaxWidth()
+            .verticalScroll(rememberScrollState()),
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+        VideoFiltersSwitch(
+            preferences = preferences,
+            onUpdatePreferences = onUpdatePreferences,
+        )
+        sliderSpecs.chunked(2).forEach { rowSpecs ->
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(16.dp),
+            ) {
+                rowSpecs.forEach { spec ->
+                    CompactVideoFilterSlider(
+                        modifier = Modifier.weight(1f),
+                        spec = spec,
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun VideoFiltersSwitch(
+    preferences: PlayerPreferences,
+    onUpdatePreferences: ((PlayerPreferences) -> PlayerPreferences) -> Unit,
+) {
+    PreferenceSwitch(
+        modifier = Modifier.testTag("switch_video_filters"),
+        title = stringResource(R.string.enable_video_filters),
+        description = stringResource(R.string.enable_video_filters_description),
+        icon = NextIcons.Sensitivity,
+        isChecked = preferences.shouldApplyVideoFilters,
+        onClick = {
+            onUpdatePreferences { it.copy(shouldApplyVideoFilters = !it.shouldApplyVideoFilters) }
+        },
+    )
+}
+
+private data class VideoFilterSliderSpec(
+    val title: String,
+    val value: Float,
+    val valueRange: ClosedFloatingPointRange<Float>,
+    val valueText: String,
+    val testTag: String,
+    val switchTestTag: String,
+    val isEnabled: Boolean,
+    val isChecked: Boolean,
+    val onCheckedChange: () -> Unit,
+    val onValueChange: (Float) -> Unit,
+)
+
+@Composable
+private fun videoFilterSliderSpecs(
+    preferences: PlayerPreferences,
+    onUpdatePreferences: ((PlayerPreferences) -> PlayerPreferences) -> Unit,
+): List<VideoFilterSliderSpec> = listOf(
+    VideoFilterSliderSpec(
+        title = stringResource(R.string.video_brightness),
+        value = preferences.videoBrightness,
+        valueRange = PlayerPreferences.MIN_VIDEO_BRIGHTNESS..PlayerPreferences.MAX_VIDEO_BRIGHTNESS,
+        valueText = signedPercent(preferences.videoBrightness),
+        testTag = "slider_video_brightness",
+        switchTestTag = "switch_video_brightness",
+        isEnabled = preferences.shouldApplyVideoFilters,
+        isChecked = preferences.isVideoBrightnessFilterEnabled,
+        onCheckedChange = {
+            onUpdatePreferences { preferences ->
+                preferences.copy(isVideoBrightnessFilterEnabled = !preferences.isVideoBrightnessFilterEnabled)
+            }
+        },
+        onValueChange = { onUpdatePreferences { preferences -> preferences.copy(videoBrightness = it) } },
+    ),
+    VideoFilterSliderSpec(
+        title = stringResource(R.string.video_contrast),
+        value = preferences.videoContrast,
+        valueRange = PlayerPreferences.MIN_VIDEO_CONTRAST..PlayerPreferences.MAX_VIDEO_CONTRAST,
+        valueText = signedPercent(preferences.videoContrast),
+        testTag = "slider_video_contrast",
+        switchTestTag = "switch_video_contrast",
+        isEnabled = preferences.shouldApplyVideoFilters,
+        isChecked = preferences.isVideoContrastFilterEnabled,
+        onCheckedChange = {
+            onUpdatePreferences { preferences ->
+                preferences.copy(isVideoContrastFilterEnabled = !preferences.isVideoContrastFilterEnabled)
+            }
+        },
+        onValueChange = { onUpdatePreferences { preferences -> preferences.copy(videoContrast = it) } },
+    ),
+    VideoFilterSliderSpec(
+        title = stringResource(R.string.video_saturation),
+        value = preferences.videoSaturation,
+        valueRange = PlayerPreferences.MIN_VIDEO_SATURATION..PlayerPreferences.MAX_VIDEO_SATURATION,
+        valueText = signedInteger(preferences.videoSaturation),
+        testTag = "slider_video_saturation",
+        switchTestTag = "switch_video_saturation",
+        isEnabled = preferences.shouldApplyVideoFilters,
+        isChecked = preferences.isVideoSaturationFilterEnabled,
+        onCheckedChange = {
+            onUpdatePreferences { preferences ->
+                preferences.copy(isVideoSaturationFilterEnabled = !preferences.isVideoSaturationFilterEnabled)
+            }
+        },
+        onValueChange = { onUpdatePreferences { preferences -> preferences.copy(videoSaturation = it) } },
+    ),
+    VideoFilterSliderSpec(
+        title = stringResource(R.string.video_hue),
+        value = preferences.videoHue,
+        valueRange = PlayerPreferences.MIN_VIDEO_HUE..PlayerPreferences.MAX_VIDEO_HUE,
+        valueText = stringResource(R.string.exo_degrees, preferences.videoHue.toInt()),
+        testTag = "slider_video_hue",
+        switchTestTag = "switch_video_hue",
+        isEnabled = preferences.shouldApplyVideoFilters,
+        isChecked = preferences.isVideoHueFilterEnabled,
+        onCheckedChange = {
+            onUpdatePreferences { preferences ->
+                preferences.copy(isVideoHueFilterEnabled = !preferences.isVideoHueFilterEnabled)
+            }
+        },
+        onValueChange = { onUpdatePreferences { preferences -> preferences.copy(videoHue = it) } },
+    ),
+    VideoFilterSliderSpec(
+        title = stringResource(R.string.video_gamma),
+        value = preferences.videoGamma,
+        valueRange = PlayerPreferences.MIN_VIDEO_GAMMA..PlayerPreferences.MAX_VIDEO_GAMMA,
+        valueText = String.format("%.2f", preferences.videoGamma),
+        testTag = "slider_video_gamma",
+        switchTestTag = "switch_video_gamma",
+        isEnabled = preferences.shouldApplyVideoFilters,
+        isChecked = preferences.isVideoGammaFilterEnabled,
+        onCheckedChange = {
+            onUpdatePreferences { preferences ->
+                preferences.copy(isVideoGammaFilterEnabled = !preferences.isVideoGammaFilterEnabled)
+            }
+        },
+        onValueChange = { onUpdatePreferences { preferences -> preferences.copy(videoGamma = it) } },
+    ),
+    VideoFilterSliderSpec(
+        title = stringResource(R.string.video_sharpening),
+        value = preferences.videoSharpening,
+        valueRange = PlayerPreferences.DEFAULT_VIDEO_SHARPENING..PlayerPreferences.MAX_VIDEO_SHARPENING,
+        valueText = stringResource(R.string.exo_percent, (preferences.videoSharpening * 100).toInt()),
+        testTag = "slider_video_sharpening",
+        switchTestTag = "switch_video_sharpening",
+        isEnabled = preferences.shouldApplyVideoFilters,
+        isChecked = preferences.isVideoSharpeningFilterEnabled,
+        onCheckedChange = {
+            onUpdatePreferences { preferences ->
+                preferences.copy(isVideoSharpeningFilterEnabled = !preferences.isVideoSharpeningFilterEnabled)
+            }
+        },
+        onValueChange = { onUpdatePreferences { preferences -> preferences.copy(videoSharpening = it) } },
+    ),
+)
+
+@Composable
+private fun VideoFilterSlider(spec: VideoFilterSliderSpec) {
+    PreferenceSlider(
+        modifier = Modifier.testTag(spec.testTag),
+        title = spec.title,
+        description = spec.valueText,
+        isEnabled = spec.isEnabled,
+        isSliderEnabled = spec.isEnabled && spec.isChecked,
+        value = spec.value,
+        valueRange = spec.valueRange,
+        onValueChange = spec.onValueChange,
+        trailingContent = {
+            NextSwitch(
+                modifier = Modifier.testTag(spec.switchTestTag),
+                isChecked = spec.isChecked,
+                onCheckedChange = { spec.onCheckedChange() },
+                isEnabled = spec.isEnabled,
+            )
+        },
+    )
+}
+
+@Composable
+private fun CompactVideoFilterSlider(
+    spec: VideoFilterSliderSpec,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier
+            .fillMaxWidth()
+            .testTag(spec.testTag),
+    ) {
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Text(
+                modifier = Modifier.weight(1f),
+                text = spec.title,
+                style = MaterialTheme.typography.bodyMedium,
+            )
+            Text(
+                modifier = Modifier.widthIn(min = 40.dp).padding(end = 8.dp),
+                text = spec.valueText,
+                textAlign = TextAlign.End,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+            NextSwitch(
+                modifier = Modifier.testTag(spec.switchTestTag),
+                isChecked = spec.isChecked,
+                onCheckedChange = { spec.onCheckedChange() },
+                isEnabled = spec.isEnabled,
+            )
+        }
+        Slider(
+            modifier = Modifier
+                .fillMaxWidth()
+                .heightIn(max = 28.dp),
+            enabled = spec.isEnabled && spec.isChecked,
+            value = spec.value,
+            valueRange = spec.valueRange,
+            onValueChange = spec.onValueChange,
+        )
+    }
+}
+
+private fun signedPercent(value: Float): String {
+    val percent = (value * 100).toInt()
+    return if (percent > 0) "+$percent%" else "$percent%"
+}
+
+private fun signedInteger(value: Float): String {
+    val rounded = value.toInt()
+    return if (rounded > 0) "+$rounded" else "$rounded"
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/designsystem/NextIcons.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/designsystem/NextIcons.kt
new file mode 100644
index 000000000..9a6f72dbd
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/designsystem/NextIcons.kt
@@ -0,0 +1,97 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.designsystem
+
+import app.gyrolet.mpvrx.ui.icons.Icons
+
+object NextIcons {
+    val Add = Icons.Default.Add
+    val Appearance = Icons.Default.Palette
+    val ArrowBack = Icons.Default.ArrowBack
+    val ArrowDownward = Icons.Default.KeyboardArrowDown
+    val ArrowUpward = Icons.Default.KeyboardArrowUp
+    val Audio = Icons.Default.Audiotrack
+    val Background = Icons.Default.Flip
+    val Bold = Icons.Default.FormatBold
+    val Brightness = Icons.Default.BrightnessHigh
+    val Calendar = Icons.Default.Update // Fallback
+    val Caption = Icons.Default.Subtitles
+    val Check = Icons.Default.Check
+    val CheckBox = Icons.Default.Check // Fallback
+    val CheckBoxOutline = Icons.Default.AddCircle // Fallback
+    val DarkMode = Icons.Default.Brightness6
+    val DashBoard = Icons.Default.GridView
+    val Decoder = Icons.Default.DeveloperBoard
+    val Delete = Icons.Default.Delete
+    val DoubleTap = Icons.Default.FastForward // Fallback
+    val Edit = Icons.Default.Edit
+    val ExpandMore = Icons.Default.ExpandMore
+    val Fast = Icons.Default.FastForward
+    val FileOpen = Icons.Default.Folder // Fallback
+    val Focus = Icons.Default.AspectRatio // Fallback
+    val Folder = Icons.Default.Folder
+    val FolderOff = Icons.Default.Folder // Fallback
+    val Font = Icons.Default.FormatSize // Fallback
+    val FontSize = Icons.Default.FormatSize
+    val Headset = Icons.Default.Headset
+    val HeadsetOff = Icons.Default.Headset // Fallback
+    val Info = Icons.Default.Add // Fallback
+    val Language = Icons.Default.Language
+    val Length = Icons.Default.AspectRatio // Fallback
+    val Link = Icons.Default.Link
+    val Location = Icons.Default.SdCard // Fallback
+    val Movie = Icons.Default.Movie
+    val Pip = Icons.Default.PictureInPictureAlt
+    val Pinch = Icons.Default.Add // Fallback
+    val Pause = Icons.Default.Pause
+    val Play = Icons.Default.PlayArrow
+    val Player = Icons.Default.PlayCircle
+    val Priority = Icons.Default.NewReleases // Fallback
+    val PlaylistPlay = Icons.Default.PlayArrow // Fallback
+    val Remove = Icons.Default.Remove
+    val Replay = Icons.Default.Refresh // Fallback
+    val Resume = Icons.Default.Add // Fallback
+    val Rotation = Icons.Default.ScreenRotation
+    val Search = Icons.Default.Search
+    val Selection = Icons.Default.Add // Fallback
+    val Settings = Icons.Outlined.Settings // Available in Outlined
+    val Share = Icons.Default.Share
+    val SkipNext = Icons.Default.SkipNext
+    val SkipPrevious = Icons.Default.SkipPrevious
+    val SmartButton = Icons.Default.AutoAwesome // Fallback
+    val Style = Icons.Default.Palette // Fallback
+    val Subtitle = Icons.Default.Subtitles
+    val Size = Icons.Default.AspectRatio // Fallback
+    val Sensitivity = Icons.Default.Tune
+    val Speed = Icons.Default.Speed
+    val SwipeHorizontal = Icons.Default.Add // Fallback
+    val SwipeVertical = Icons.Default.Add // Fallback
+    val Tap = Icons.Default.Add // Fallback
+    val Timer = Icons.Default.Add // Fallback
+    val Title = Icons.Default.Add // Fallback
+    val Update = Icons.Default.Update
+    val Video = Icons.Default.Movie
+    val VolumeUp = Icons.Default.VolumeUp
+    val ButtonsPosition = Icons.Default.GridView // Fallback
+    val Cloud = Icons.Default.CloudDownload // Fallback
+    val Close = Icons.Default.Close
+    val History = Icons.Default.History
+    val DragHandle = Icons.Default.DragHandle
+    val Pan = Icons.Default.Add // Fallback
+    val HideSource = Icons.Filled.Block
+    val SelectAll = Icons.Default.Add // Fallback
+    val DeselectAll = Icons.Default.RemoveCircle
+    val FastForward = Icons.Default.FastForward
+    val BugReport = Icons.Outlined.BugReport // Available in Outlined
+    val Copy = Icons.Default.ContentCopy
+    val ExtraSettings = Icons.Default.MoreVert // Fallback
+    val DeleteSweep = Icons.Default.Delete // Fallback
+    val Image = Icons.Default.CameraAlt // Fallback
+    val Frame = Icons.Default.FitScreen // Fallback
+    val Menu = Icons.Default.MoreVert // Fallback
+    val Lock = Icons.Filled.Lock // Available in Filled
+    val Loop = Icons.Filled.Repeat // Available in Filled
+    val LoopOne = Icons.Filled.RepeatOne
+    val LoopAll = Icons.Filled.RepeatOn
+    val Shuffle = Icons.Default.Shuffle
+    val ShuffleOn = Icons.Default.ShuffleOn
+    val Screenshot = Icons.Default.Screenshot
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/extensions/PaddingValues.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/extensions/PaddingValues.kt
new file mode 100644
index 000000000..6e6848765
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/core/ui/extensions/PaddingValues.kt
@@ -0,0 +1,41 @@
+package app.gyrolet.mpvrx.exoplayer.core.ui.extensions
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.calculateEndPadding
+import androidx.compose.foundation.layout.calculateStartPadding
+import androidx.compose.foundation.layout.navigationBars
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+@Composable
+operator fun PaddingValues.plus(other: PaddingValues): PaddingValues = PaddingValues(
+    top = this.calculateTopPadding() + other.calculateTopPadding(),
+    bottom = this.calculateBottomPadding() + other.calculateBottomPadding(),
+    start = this.calculateStartPadding(LocalLayoutDirection.current) +
+        other.calculateStartPadding(LocalLayoutDirection.current),
+    end = this.calculateEndPadding(LocalLayoutDirection.current) +
+        other.calculateEndPadding(LocalLayoutDirection.current),
+)
+
+@Composable
+fun PaddingValues.copy(
+    top: Dp = this.calculateTopPadding(),
+    bottom: Dp = this.calculateBottomPadding(),
+    start: Dp = this.calculateStartPadding(LocalLayoutDirection.current),
+    end: Dp = this.calculateEndPadding(LocalLayoutDirection.current),
+): PaddingValues = PaddingValues(start, top, end, bottom)
+
+@Composable
+fun PaddingValues.withBottomFallback(
+    fallback: Dp = 24.dp,
+): PaddingValues {
+    val bottomPadding = calculateBottomPadding()
+    val navigationBarBottomPadding = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding()
+    return copy(
+        bottom = maxOf(bottomPadding, navigationBarBottomPadding) + fallback,
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/di/ExoPlayerModule.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/di/ExoPlayerModule.kt
new file mode 100644
index 000000000..5282329a1
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/di/ExoPlayerModule.kt
@@ -0,0 +1,127 @@
+package app.gyrolet.mpvrx.exoplayer.di
+
+import androidx.datastore.core.DataStoreFactory
+import androidx.datastore.core.handlers.ReplaceFileCorruptionHandler
+import androidx.datastore.dataStoreFile
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.LocalMediaRepositoryImpl
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.LocalPreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.MediaRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.SubtitleFontRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.LocalSubtitleFontRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.SubtitleFontFileValidator
+import app.gyrolet.mpvrx.exoplayer.core.datastore.datasource.AppPreferencesDataSource
+import app.gyrolet.mpvrx.exoplayer.core.datastore.datasource.PlayerPreferencesDataSource
+import app.gyrolet.mpvrx.exoplayer.core.datastore.serializer.ApplicationPreferencesSerializer
+import app.gyrolet.mpvrx.exoplayer.core.datastore.serializer.PlayerPreferencesSerializer
+import app.gyrolet.mpvrx.exoplayer.core.datastore.serializer.SearchHistorySerializer
+import app.gyrolet.mpvrx.exoplayer.core.domain.GetSortedPlaylistUseCase
+import app.gyrolet.mpvrx.exoplayer.core.domain.GetSortedVideosUseCase
+import app.gyrolet.mpvrx.exoplayer.feature.player.PlayerViewModel
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.OnlineSubtitleRepository
+import app.gyrolet.mpvrx.exoplayer.MediaSynchronizer
+import app.gyrolet.mpvrx.exoplayer.core.datastore.datasource.SearchHistoryDataSource
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.SearchHistoryRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.LocalSearchHistoryRepository
+import app.gyrolet.mpvrx.exoplayer.core.model.ApplicationPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.SearchHistory
+import app.gyrolet.mpvrx.exoplayer.settings.screens.medialibrary.MediaLibraryPreferencesViewModel
+import app.gyrolet.mpvrx.exoplayer.settings.screens.player.PlayerPreferencesViewModel
+import app.gyrolet.mpvrx.exoplayer.settings.screens.gesture.GesturePreferencesViewModel
+import app.gyrolet.mpvrx.exoplayer.settings.screens.decoder.DecoderPreferencesViewModel
+import app.gyrolet.mpvrx.exoplayer.settings.screens.audio.AudioPreferencesViewModel
+import app.gyrolet.mpvrx.exoplayer.settings.screens.subtitle.SubtitlePreferencesViewModel
+import app.gyrolet.mpvrx.exoplayer.settings.screens.general.GeneralPreferencesViewModel
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import org.koin.android.ext.koin.androidContext
+import org.koin.core.module.dsl.viewModelOf
+import org.koin.core.qualifier.named
+import org.koin.dsl.module
+
+private const val APP_PREFERENCES_DATASTORE_FILE = "exo_app_preferences.json"
+private const val PLAYER_PREFERENCES_DATASTORE_FILE = "exo_player_preferences.json"
+private const val SEARCH_HISTORY_DATASTORE_FILE = "exo_search_history.json"
+
+val exoPlayerModule = module {
+    single(named("exoCoroutineScope")) { CoroutineScope(SupervisorJob() + Dispatchers.Main) }
+    single(named("ioDispatcher")) { Dispatchers.IO }
+    single(named("defaultDispatcher")) { Dispatchers.Default }
+
+    single(named("appPreferencesDataStore")) {
+        android.util.Log.d("ExoPlayerModule", "Creating appPreferencesDataStore")
+        DataStoreFactory.create(
+            serializer = ApplicationPreferencesSerializer,
+            corruptionHandler = ReplaceFileCorruptionHandler { ApplicationPreferences() },
+            scope = CoroutineScope(get<CoroutineScope>(named("exoCoroutineScope")).coroutineContext + get<CoroutineDispatcher>(named("ioDispatcher"))),
+            produceFile = { androidContext().dataStoreFile(APP_PREFERENCES_DATASTORE_FILE) },
+        )
+    }
+
+    single(named("playerPreferencesDataStore")) {
+        android.util.Log.d("ExoPlayerModule", "Creating playerPreferencesDataStore")
+        DataStoreFactory.create(
+            serializer = PlayerPreferencesSerializer,
+            corruptionHandler = ReplaceFileCorruptionHandler { PlayerPreferences() },
+            scope = CoroutineScope(get<CoroutineScope>(named("exoCoroutineScope")).coroutineContext + get<CoroutineDispatcher>(named("ioDispatcher"))),
+            produceFile = { androidContext().dataStoreFile(PLAYER_PREFERENCES_DATASTORE_FILE) },
+        )
+    }
+
+    single(named("searchHistoryDataStore")) {
+        android.util.Log.d("ExoPlayerModule", "Creating searchHistoryDataStore")
+        DataStoreFactory.create(
+            serializer = SearchHistorySerializer,
+            corruptionHandler = ReplaceFileCorruptionHandler { SearchHistory() },
+            scope = CoroutineScope(get<CoroutineScope>(named("exoCoroutineScope")).coroutineContext + get<CoroutineDispatcher>(named("ioDispatcher"))),
+            produceFile = { androidContext().dataStoreFile(SEARCH_HISTORY_DATASTORE_FILE) },
+        )
+    }
+
+    single { AppPreferencesDataSource(get(named("appPreferencesDataStore"))) }
+    single { PlayerPreferencesDataSource(get(named("playerPreferencesDataStore"))) }
+    single { SearchHistoryDataSource(get(named("searchHistoryDataStore"))) }
+
+    single<PreferencesRepository> {
+        LocalPreferencesRepository(get(), get(), get<CoroutineScope>(named("exoCoroutineScope")))
+    }
+
+    single<MediaRepository> {
+        LocalMediaRepositoryImpl(androidContext(), get())
+    }
+
+    single<SearchHistoryRepository> {
+        LocalSearchHistoryRepository(get())
+    }
+
+    single { SubtitleFontFileValidator() }
+    single<SubtitleFontRepository> { 
+        LocalSubtitleFontRepository(androidContext(), get<CoroutineScope>(named("exoCoroutineScope")), get(named("ioDispatcher")), get()) 
+    }
+    
+    single { GetSortedVideosUseCase(get(), get(), get(named("defaultDispatcher"))) }
+    single { GetSortedPlaylistUseCase(get(), get(), androidContext(), get(named("defaultDispatcher"))) }
+    
+    single { OnlineSubtitleRepository(androidContext()) }
+    
+    single<MediaSynchronizer> {
+        object : MediaSynchronizer {
+            override suspend fun refresh(path: String?): Boolean = true
+            override suspend fun registerManualVideoPath(path: String) {}
+            override fun startSync() {}
+            override fun stopSync() {}
+        }
+    }
+
+    viewModelOf(::PlayerViewModel)
+    viewModelOf(::MediaLibraryPreferencesViewModel)
+    viewModelOf(::PlayerPreferencesViewModel)
+    viewModelOf(::GesturePreferencesViewModel)
+    viewModelOf(::DecoderPreferencesViewModel)
+    viewModelOf(::AudioPreferencesViewModel)
+    viewModelOf(::SubtitlePreferencesViewModel)
+    viewModelOf(::GeneralPreferencesViewModel)
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ExoPlayerService.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ExoPlayerService.kt
new file mode 100644
index 000000000..e02cbbc6c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ExoPlayerService.kt
@@ -0,0 +1,2436 @@
+package app.gyrolet.mpvrx.exoplayer
+
+import android.app.PendingIntent
+import android.content.ContentResolver
+import android.content.Intent
+import android.graphics.Bitmap
+import android.media.MediaMetadataRetriever
+import android.media.audiofx.LoudnessEnhancer
+import android.net.Uri
+import android.os.Bundle
+import android.os.SystemClock
+import android.provider.MediaStore
+import androidx.annotation.OptIn
+import androidx.core.net.toFile
+import androidx.core.net.toUri
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.C
+import androidx.media3.common.Effect
+import androidx.media3.common.Format
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.ParserException
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.Player
+import androidx.media3.common.Player.DISCONTINUITY_REASON_AUTO_TRANSITION
+import androidx.media3.common.Player.DISCONTINUITY_REASON_REMOVE
+import androidx.media3.common.Player.DISCONTINUITY_REASON_SEEK
+import androidx.media3.common.TrackSelectionParameters
+import androidx.media3.common.Tracks
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.datasource.DataSpec
+import androidx.media3.datasource.DefaultDataSource
+import androidx.media3.datasource.okhttp.OkHttpDataSource
+import androidx.media3.exoplayer.ExoPlaybackException
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.analytics.AnalyticsListener
+import androidx.media3.exoplayer.drm.DrmSessionManagerProvider
+import androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
+import androidx.media3.exoplayer.mediacodec.MediaCodecUtil
+import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
+import androidx.media3.exoplayer.source.MediaSource
+import androidx.media3.extractor.ExtractorsFactory
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.extensionRendererMode
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.logName
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.shouldEnableDecoderFallback
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.shouldRetryWithSoftwareDecoder
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.shouldUseAudioExtensionFallback
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.shouldApplyVideoEffects
+import androidx.media3.exoplayer.trackselection.DefaultTrackSelector
+import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
+import androidx.media3.extractor.DefaultExtractorsFactory
+import androidx.media3.extractor.Extractor
+import androidx.media3.extractor.ExtractorInput
+import androidx.media3.extractor.ExtractorOutput
+import androidx.media3.extractor.PositionHolder
+import androidx.media3.extractor.mkv.MatroskaExtractor
+import androidx.media3.extractor.mp4.Mp4Extractor
+import androidx.media3.extractor.text.SubtitleParser
+import androidx.media3.session.CommandButton
+import androidx.media3.session.CommandButton.ICON_UNDEFINED
+import androidx.media3.session.MediaSession
+import androidx.media3.session.MediaSessionService
+import androidx.media3.session.SessionCommand
+import androidx.media3.session.SessionError
+import androidx.media3.session.SessionResult
+import coil3.ImageLoader
+import coil3.request.ImageRequest
+import coil3.request.SuccessResult
+import coil3.toBitmap
+import com.google.common.util.concurrent.ListenableFuture
+import io.github.anilbeesetti.nextlib.media3ext.renderer.subtitleDelayMilliseconds
+import io.github.anilbeesetti.nextlib.media3ext.renderer.subtitleSpeed
+import io.github.peerless2012.ass.media.AssHandler
+import io.github.peerless2012.ass.media.kt.withAssSupport
+import io.github.peerless2012.ass.media.parser.AssSubtitleParserFactory
+import io.github.peerless2012.ass.media.type.AssRenderType
+import java.io.ByteArrayOutputStream
+import java.io.DataInputStream
+import java.io.DataOutputStream
+import java.io.File
+import java.io.InputStream
+import java.util.concurrent.ConcurrentHashMap
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.guava.future
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.supervisorScope
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.deleteFiles
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.getFilenameFromUri
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.getLocalSubtitles
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.getPath
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.matchesSubtitleBase
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.subtitleCacheDir
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.MediaRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.buildPlaybackStateCandidates
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.buildRemoteFolderPlaybackAnchorKey
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.buildRemotePlaybackStateKey
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.isRemotePlaybackStateKey
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+import app.gyrolet.mpvrx.exoplayer.core.model.LoopMode
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.RemoteFile
+import app.gyrolet.mpvrx.exoplayer.core.model.RemoteServer
+import app.gyrolet.mpvrx.exoplayer.core.model.Resume
+import app.gyrolet.mpvrx.exoplayer.core.model.ServerProtocol
+import app.gyrolet.mpvrx.exoplayer.feature.player.datasource.FtpDataSource
+import app.gyrolet.mpvrx.exoplayer.feature.player.datasource.SmbDataSource
+import app.gyrolet.mpvrx.exoplayer.feature.player.engine.media3.MkvCuesParser
+import app.gyrolet.mpvrx.exoplayer.feature.player.engine.media3.SeekMapInjectingExtractor
+import app.gyrolet.mpvrx.exoplayer.feature.player.engine.media3.buildSeekMapFromCues
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.addAdditionalSubtitleConfiguration
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.audioTrackIndex
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.copy
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.getManuallySelectedTrackIndex
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.getSubtitleMime
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.isApproximateSeekEnabled
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.isVideoEffectsAvailable
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.localParentPath
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.positionMs
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.remoteDirectoryPath
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.remoteFilePath
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.remoteProtocol
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.remoteServerId
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.requestHeaders
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.setMetadataExtras
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.OnlineSubtitleRepository
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.setIsScrubbingModeEnabled
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.subtitleDelayMilliseconds
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.subtitleSpeed
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.subtitleTrackIndex
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.switchTrack
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.uriToSubtitleConfiguration
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.videoZoom
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.CustomCommands
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.NormalizingRenderersFactory
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.VideoEffectsState
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.VideoFilterPreferences
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.VideoFiltersEffect
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.VideoFilterTransition
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.VolumeNormalizationAudioProcessor
+import app.gyrolet.mpvrx.exoplayer.feature.player.subtitle.AssHandlerRegistry
+import app.gyrolet.mpvrx.exoplayer.feature.player.subtitle.NormalizingAssMatroskaExtractor
+import org.koin.android.ext.android.inject
+
+@OptIn(UnstableApi::class)
+class ExoPlayerService : MediaSessionService() {
+
+    private val serviceScope: CoroutineScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+    private var mediaSession: MediaSession? = null
+
+    companion object {
+        private const val TAG = "ExoPlayerService"
+        private const val FAST_SEEK_MIN_DELTA_MS = 2_000L
+        private const val STARTUP_PRECISE_RESUME_THRESHOLD_MS = 10_000L
+        private const val MKV_CUES_CACHE_MAGIC = 0x4E505145
+        private val DIRECT_SUBTITLE_URI_SCHEMES = setOf("smb", "ftp")
+        private val REMOTE_SOURCE_URI_SCHEMES = setOf("smb", "ftp")
+
+        private val ISO_639_2T_TO_1 = mapOf(
+            "zho" to "zh", "chi" to "zh",
+            "eng" to "en",
+            "jpn" to "ja",
+            "kor" to "ko",
+            "fra" to "fr", "fre" to "fr",
+            "deu" to "de", "ger" to "de",
+            "spa" to "es",
+            "por" to "pt",
+            "rus" to "ru",
+            "ara" to "ar",
+            "tha" to "th",
+            "vie" to "vi",
+            "ita" to "it",
+            "pol" to "pl",
+            "nld" to "nl", "dut" to "nl",
+            "tur" to "tr",
+            "ind" to "id",
+            "msa" to "ms", "may" to "ms",
+        )
+        private val REMOTE_SUBTITLE_EXTENSIONS = setOf(
+            "ass",
+            "srt",
+            "ssa",
+            "ttml",
+            "vtt",
+        )
+        private const val VIDEO_FILTER_PREVIEW_DELAY_MS = 40L
+        private const val VIDEO_FILTER_TRANSITION_DURATION_MS = 160L
+        private const val PAUSED_FRAME_REFRESH_OFFSET_MS = 50L
+    }
+
+    val preferencesRepository: PreferencesRepository by inject()
+    val mediaRepository: MediaRepository by inject()
+    val onlineSubtitleRepository: OnlineSubtitleRepository by inject()
+    val imageLoader: ImageLoader by inject()
+
+    private val playerPreferences: PlayerPreferences
+        get() = preferencesRepository.playerPreferences.value
+
+    private fun updateFolderPlaybackAnchor(mediaItem: MediaItem) {
+        val preferences = preferencesRepository.applicationPreferences.value
+        if (!preferences.shouldRestoreLastPlayedMediaInFolders) return
+
+        serviceScope.launch {
+            val playbackStateUri = mediaItem.resolvePlaybackStateUri()
+            val localParentPath = mediaItem.mediaMetadata.localParentPath
+                ?: mediaRepository.getVideoByUri(playbackStateUri)?.parentPath
+                    ?.takeIf { it.isNotBlank() }
+            val remoteAnchorKey = buildRemoteFolderPlaybackAnchorKey(
+                remoteProtocol = mediaItem.mediaMetadata.remoteProtocol,
+                remoteServerId = mediaItem.mediaMetadata.remoteServerId,
+                directoryPath = mediaItem.mediaMetadata.remoteDirectoryPath,
+            )
+
+            preferencesRepository.updateApplicationPreferences { currentPreferences ->
+                var updatedPreferences = currentPreferences
+
+                if (!localParentPath.isNullOrBlank()) {
+                    updatedPreferences = updatedPreferences.copy(
+                        localFolderLastPlayedMediaUris = updatedPreferences.localFolderLastPlayedMediaUris +
+                            (localParentPath to playbackStateUri),
+                    )
+                }
+
+                if (remoteAnchorKey != null) {
+                    val remoteFilePath = mediaItem.mediaMetadata.remoteFilePath ?: return@updateApplicationPreferences updatedPreferences
+                    updatedPreferences = updatedPreferences.copy(
+                        remoteFolderLastPlayedMediaPaths = updatedPreferences.remoteFolderLastPlayedMediaPaths +
+                            (remoteAnchorKey to remoteFilePath),
+                    )
+                }
+
+                updatedPreferences
+            }
+        }
+    }
+
+    private val customCommands = CustomCommands.asSessionCommands()
+
+    private var isMediaItemReady = false
+
+    private val volumeNormalizationAudioProcessor = VolumeNormalizationAudioProcessor()
+    private var loudnessEnhancer: LoudnessEnhancer? = null
+    private var requestedVolumeGain: Int = 0
+    private val mediaParserRetried = mutableSetOf<String>()
+    private val softwareDecoderRetried = mutableSetOf<String>()
+    private var isPendingExternalSubAutoSelect = false
+    private var assHandler: AssHandler? = null
+    private var pendingPreciseSeekPromotionJob: Job? = null
+    private var preciseSeekRequestId = 0L
+    private var pendingStartupPreciseResumeToken: String? = null
+    private var pendingStartupPreciseResumePositionMs: Long? = null
+    private var activeDecoderPriority: DecoderPriority = DecoderPriority.AUTOMATIC
+    private var currentVideoEffectsState = VideoEffectsState(
+        filters = VideoFilterPreferences.default(),
+        decoderPriority = DecoderPriority.AUTOMATIC,
+    )
+    private var activeVideoFiltersEffect: VideoFiltersEffect? = null
+    private var isCurrentVideoHdr = false
+    private var hasRenderedFirstFrameForCurrentItem = false
+    private var pendingVideoFiltersJob: Job? = null
+    private var videoFilterTransition = VideoFilterTransition.default()
+    private var screenAspectRatio: Float = 0f
+    private lateinit var fastStartMediaSourceFactory: DefaultMediaSourceFactory
+    private lateinit var preciseSeekMediaSourceFactory: DefaultMediaSourceFactory
+    private var sessionLoadErrorHandlingPolicy: LoadErrorHandlingPolicy? = null
+    private var sessionDrmSessionManagerProvider: DrmSessionManagerProvider? = null
+    private lateinit var sessionMediaSourceFactory: MediaSource.Factory
+    private lateinit var assSubtitleParserFactory: AssSubtitleParserFactory
+
+    private val mkvSeekMapCache = ConcurrentHashMap<String, androidx.media3.extractor.SeekMap>()
+    private val mkvCueParseJobs = ConcurrentHashMap<String, Deferred<androidx.media3.extractor.SeekMap?>>()
+    private val preciseSeekMediaIds = ConcurrentHashMap.newKeySet<String>()
+
+    private var startupTimestamp = 0L
+    private val startupAnalyticsListener = object : AnalyticsListener {
+        override fun onPlaybackStateChanged(
+            eventTime: AnalyticsListener.EventTime,
+            state: Int,
+        ) {
+            if (state == Player.STATE_BUFFERING) {
+                startupTimestamp = System.currentTimeMillis()
+            }
+            val label = when (state) {
+                Player.STATE_IDLE -> "IDLE"
+                Player.STATE_BUFFERING -> "BUFFERING"
+                Player.STATE_READY -> "READY"
+                Player.STATE_ENDED -> "ENDED"
+                else -> "UNKNOWN($state)"
+            }
+            Logger.info(TAG, "startup state=$label t=${elapsed()}ms")
+        }
+
+        override fun onLoadStarted(
+            eventTime: AnalyticsListener.EventTime,
+            loadEventInfo: androidx.media3.exoplayer.source.LoadEventInfo,
+            mediaLoadData: androidx.media3.exoplayer.source.MediaLoadData,
+            retryCount: Int,
+        ) {
+            Logger.info(TAG, "startup loadStart t=${elapsed()}ms type=${mediaLoadData.dataType}")
+        }
+
+        override fun onLoadCompleted(
+            eventTime: AnalyticsListener.EventTime,
+            loadEventInfo: androidx.media3.exoplayer.source.LoadEventInfo,
+            mediaLoadData: androidx.media3.exoplayer.source.MediaLoadData,
+        ) {
+            Logger.info(
+                TAG,
+                "startup loadDone t=${elapsed()}ms type=${mediaLoadData.dataType} bytes=${loadEventInfo.bytesLoaded}",
+            )
+        }
+
+        override fun onRenderedFirstFrame(
+            eventTime: AnalyticsListener.EventTime,
+            output: Any,
+            renderTimeMs: Long,
+        ) {
+            Logger.info(TAG, "startup firstFrame t=${elapsed()}ms")
+        }
+
+        override fun onVideoDecoderInitialized(
+            eventTime: AnalyticsListener.EventTime,
+            decoderName: String,
+            initializedTimestampMs: Long,
+            initializationDurationMs: Long,
+        ) {
+            Logger.info(TAG, "startup decoderInit=$decoderName dur=${initializationDurationMs}ms t=${elapsed()}ms")
+        }
+
+        override fun onAudioDecoderInitialized(
+            eventTime: AnalyticsListener.EventTime,
+            decoderName: String,
+            initializedTimestampMs: Long,
+            initializationDurationMs: Long,
+        ) {
+            Logger.info(TAG, "startup audioDecoder=$decoderName dur=${initializationDurationMs}ms t=${elapsed()}ms")
+        }
+
+        override fun onTracksChanged(
+            eventTime: AnalyticsListener.EventTime,
+            tracks: androidx.media3.common.Tracks,
+        ) {
+            val player = mediaSession?.player
+            Logger.info(
+                TAG,
+                "startup tracksChanged t=${elapsed()}ms groups=${tracks.groups.size} seekable=${player?.isCurrentMediaItemSeekable} duration=${player?.duration}",
+            )
+        }
+    }
+
+    private fun elapsed(): Long = System.currentTimeMillis() - startupTimestamp
+
+    private fun resolveTransitionPlaybackSpeed(
+        transitionReason: Int,
+        currentPlaybackSpeed: Float,
+    ): Float = when (transitionReason) {
+        Player.MEDIA_ITEM_TRANSITION_REASON_AUTO,
+        Player.MEDIA_ITEM_TRANSITION_REASON_SEEK,
+        -> currentPlaybackSpeed
+
+        Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED,
+        Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT,
+        -> playerPreferences.defaultPlaybackSpeed
+
+        else -> playerPreferences.defaultPlaybackSpeed
+    }
+
+    private val playbackStateListener = object : Player.Listener {
+        override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+            super.onMediaItemTransition(mediaItem, reason)
+            if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT) {
+                handleRepeatedPlayback(mediaSession?.player ?: return)
+                return
+            }
+            isCurrentVideoHdr = false
+            hasRenderedFirstFrameForCurrentItem = false
+            pendingPreciseSeekPromotionJob?.cancel()
+            pendingPreciseSeekPromotionJob = null
+            preciseSeekRequestId++
+            pendingStartupPreciseResumeToken = null
+            pendingStartupPreciseResumePositionMs = null
+            isMediaItemReady = false
+            isPendingExternalSubAutoSelect = false
+            updateCurrentVideoEffectsAvailability(mediaSession?.player as? ExoPlayer ?: return)
+            if (mediaItem != null) {
+                serviceScope.launch {
+                    val playbackStateUri = mediaItem.resolvePlaybackStateUri()
+                    mediaRepository.updateMediumLastPlayedTime(
+                        uri = playbackStateUri,
+                        lastPlayedTime = System.currentTimeMillis(),
+                    )
+                }
+            }
+            mediaItem?.mediaMetadata?.let { metadata ->
+                mediaSession?.player?.run {
+                    setPlaybackSpeed(
+                        resolveTransitionPlaybackSpeed(
+                            transitionReason = reason,
+                            currentPlaybackSpeed = playbackParameters.speed,
+                        ),
+                    )
+                    playerSpecificSubtitleDelayMilliseconds = metadata.subtitleDelayMilliseconds ?: 0L
+                    playerSpecificSubtitleSpeed = metadata.subtitleSpeed ?: 1f
+                }
+
+                val resumePositionMs = metadata.positionMs?.takeIf { playerPreferences.resume == Resume.YES }
+                if (metadata.isApproximateSeekEnabled) {
+                    val restoredSeekMap = restoreCachedMkvSeekMap(mediaItem)
+                    if (restoredSeekMap != null) {
+                        mkvSeekMapCache[mediaItem.mediaId] = restoredSeekMap
+                    }
+                    scheduleMkvCueCache(mediaItem)
+
+                    if (restoredSeekMap != null) {
+                        preciseSeekMediaIds.add(mediaItem.mediaId)
+                        resumePositionMs?.takeIf { it >= STARTUP_PRECISE_RESUME_THRESHOLD_MS }?.let {
+                            Logger.info(TAG, "Resume cached precise-seek media item=${mediaItem.mediaId} position=$it")
+                            mediaSession?.player?.seekTo(it)
+                        }
+                    } else {
+                        resumePositionMs?.takeIf { it > 0L }?.let {
+                            Logger.info(TAG, "Resume deferred precise-seek media item=${mediaItem.mediaId} position=$it")
+                            pendingStartupPreciseResumeToken = mediaItem.mediaId
+                            pendingStartupPreciseResumePositionMs = it
+                        }
+                    }
+                    return
+                }
+
+                resumePositionMs?.let {
+                    mediaSession?.player?.seekTo(it)
+                }
+            }
+        }
+
+        override fun onPositionDiscontinuity(
+            oldPosition: Player.PositionInfo,
+            newPosition: Player.PositionInfo,
+            reason: Int,
+        ) {
+            super.onPositionDiscontinuity(oldPosition, newPosition, reason)
+            val oldMediaItem = oldPosition.mediaItem ?: return
+
+            when (reason) {
+                DISCONTINUITY_REASON_SEEK,
+                DISCONTINUITY_REASON_AUTO_TRANSITION,
+                -> {
+                    if (newPosition.mediaItem == null || oldMediaItem == newPosition.mediaItem) return
+
+                    val player = mediaSession?.player ?: return
+                    val updatedPosition = oldPosition.positionMs.takeIf { reason == DISCONTINUITY_REASON_SEEK } ?: C.TIME_UNSET
+                    val mediaItemToUpdate = player.getMediaItemAt(oldPosition.mediaItemIndex)
+                        .takeIf { it.mediaId == oldMediaItem.mediaId }
+                        ?: oldMediaItem
+
+                    player.replaceMediaItem(
+                        oldPosition.mediaItemIndex,
+                        mediaItemToUpdate.copy(positionMs = updatedPosition),
+                    )
+                    serviceScope.launch {
+                        val playbackStateUri = oldMediaItem.resolvePlaybackStateUri()
+                        mediaRepository.updateMediumPosition(
+                            uri = playbackStateUri,
+                            position = updatedPosition,
+                        )
+                    }
+                }
+
+                DISCONTINUITY_REASON_REMOVE -> {
+                    serviceScope.launch {
+                        val durationMs = oldMediaItem.mediaMetadata.durationMs
+                        val isAtEnd = durationMs != null && oldPosition.positionMs >= durationMs - 1000
+                        val playbackStateUri = oldMediaItem.resolvePlaybackStateUri()
+                        mediaRepository.updateMediumPosition(
+                            uri = playbackStateUri,
+                            position = if (isAtEnd) C.TIME_UNSET else oldPosition.positionMs,
+                        )
+                    }
+                }
+
+                else -> return
+            }
+        }
+
+        override fun onTracksChanged(tracks: Tracks) {
+            super.onTracksChanged(tracks)
+            if (tracks.groups.isEmpty()) return
+
+            if (isPendingExternalSubAutoSelect) {
+                isPendingExternalSubAutoSelect = false
+                if (!playerPreferences.isSubtitleAutoLoadEnabled) return
+                val player = mediaSession?.player ?: return
+                val textTracks = tracks.groups.filter { it.type == C.TRACK_TYPE_TEXT && it.isSupported }
+                if (textTracks.isNotEmpty()) {
+                    val rememberedSubtitleTrackIndex = player.currentMediaItem?.mediaMetadata?.subtitleTrackIndex
+                    when {
+                        rememberedSubtitleTrackIndex == -1 -> player.switchTrack(C.TRACK_TYPE_TEXT, -1)
+                        rememberedSubtitleTrackIndex in textTracks.indices -> player.switchTrack(
+                            C.TRACK_TYPE_TEXT,
+                            rememberedSubtitleTrackIndex ?: -1,
+                        )
+                        else -> player.switchTrack(C.TRACK_TYPE_TEXT, findBestSubtitleTrackIndex(textTracks))
+                    }
+                }
+                return
+            }
+
+            if (isMediaItemReady) return
+            isMediaItemReady = true
+
+            val player = mediaSession?.player ?: return
+            val metadata = player.mediaMetadata
+            if (playerPreferences.shouldRememberSelections) {
+                metadata.audioTrackIndex?.let { player.switchTrack(C.TRACK_TYPE_AUDIO, it) }
+            }
+
+            if (!playerPreferences.isSubtitleAutoLoadEnabled) {
+                player.switchTrack(C.TRACK_TYPE_TEXT, -1)
+                return
+            }
+
+            val textTracks = tracks.groups.filter { it.type == C.TRACK_TYPE_TEXT && it.isSupported }
+            if (textTracks.isNotEmpty()) {
+                when {
+                    metadata.subtitleTrackIndex == -1 -> player.switchTrack(C.TRACK_TYPE_TEXT, -1)
+                    metadata.subtitleTrackIndex in textTracks.indices -> player.switchTrack(C.TRACK_TYPE_TEXT, metadata.subtitleTrackIndex!!)
+                    else -> player.switchTrack(C.TRACK_TYPE_TEXT, findBestSubtitleTrackIndex(textTracks))
+                }
+            }
+            val currentMediaItem = player.currentMediaItem ?: return
+            loadExternalSubtitlesForCurrentItem(
+                mediaId = currentMediaItem.mediaId,
+                requestHeaders = currentMediaItem.mediaMetadata.requestHeaders,
+            )
+        }
+
+        override fun onTrackSelectionParametersChanged(parameters: TrackSelectionParameters) {
+            super.onTrackSelectionParametersChanged(parameters)
+            val player = mediaSession?.player ?: return
+            val currentMediaItem = player.currentMediaItem ?: return
+
+            val audioTrackIndex = player.getManuallySelectedTrackIndex(C.TRACK_TYPE_AUDIO)
+            val subtitleTrackIndex = player.getManuallySelectedTrackIndex(C.TRACK_TYPE_TEXT)
+
+            serviceScope.launch {
+                val playbackStateUri = currentMediaItem.resolvePlaybackStateUri()
+                if (audioTrackIndex != null) {
+                    mediaRepository.updateMediumAudioTrack(
+                        uri = playbackStateUri,
+                        audioTrackIndex = audioTrackIndex,
+                    )
+                }
+                if (subtitleTrackIndex != null) {
+                    mediaRepository.updateMediumSubtitleTrack(
+                        uri = playbackStateUri,
+                        subtitleTrackIndex = subtitleTrackIndex,
+                    )
+                }
+            }
+
+            player.replaceMediaItem(
+                player.currentMediaItemIndex,
+                currentMediaItem.copy(
+                    audioTrackIndex = audioTrackIndex,
+                    subtitleTrackIndex = subtitleTrackIndex,
+                ),
+            )
+        }
+
+        override fun onPlaybackStateChanged(playbackState: Int) {
+            super.onPlaybackStateChanged(playbackState)
+            if (playbackState == Player.STATE_IDLE) {
+                val player = mediaSession?.player ?: return
+                player.trackSelectionParameters = TrackSelectionParameters.DEFAULT
+                player.setPlaybackSpeed(playerPreferences.defaultPlaybackSpeed)
+                return
+            }
+
+            if (playbackState == Player.STATE_ENDED) {
+                val player = mediaSession?.player ?: return
+                player.setPlaybackSpeed(playerPreferences.defaultPlaybackSpeed)
+                return
+            }
+
+            if (playbackState == Player.STATE_READY) {
+                val player = mediaSession?.player ?: return
+                val currentMediaItem = player.currentMediaItem ?: return
+                serviceScope.launch {
+                    val playbackStateUri = currentMediaItem.resolvePlaybackStateUri()
+                    mediaRepository.updateMediumLastPlayedTime(
+                        uri = playbackStateUri,
+                        lastPlayedTime = System.currentTimeMillis(),
+                    )
+                }
+                updateFolderPlaybackAnchor(currentMediaItem)
+            }
+        }
+
+        override fun onPlayWhenReadyChanged(shouldPlayWhenReady: Boolean, reason: Int) {
+            super.onPlayWhenReadyChanged(shouldPlayWhenReady, reason)
+            if (reason != Player.PLAY_WHEN_READY_CHANGE_REASON_END_OF_MEDIA_ITEM) return
+
+            val player = mediaSession?.player ?: return
+            if (player.repeatMode != Player.REPEAT_MODE_OFF) {
+                player.seekTo(0)
+                handleRepeatedPlayback(player)
+                player.play()
+                return
+            }
+            player.clearMediaItems()
+            player.stop()
+            stopSelf()
+        }
+
+        override fun onRenderedFirstFrame() {
+            super.onRenderedFirstFrame()
+            val player = mediaSession?.player ?: return
+            val currentMediaItem = player.currentMediaItem ?: return
+
+            val format = player.currentTracks.groups
+                .firstOrNull { it.type == C.TRACK_TYPE_VIDEO }
+                ?.getTrackFormat(0)
+            val width = format?.width ?: 0
+            val height = format?.height ?: 0
+            val rotation = format?.rotationDegrees ?: 0
+            val transfer = format?.colorInfo?.colorTransfer
+            isCurrentVideoHdr = transfer == C.COLOR_TRANSFER_ST2084 || transfer == C.COLOR_TRANSFER_HLG
+            Logger.info(
+                TAG,
+                "startup firstFrameReady format=${width}x$height rot=$rotation duration=${player.duration} seekable=${player.isCurrentMediaItemSeekable} hdr=$isCurrentVideoHdr",
+            )
+
+            val duration = player.duration.takeIf { it != C.TIME_UNSET }
+            val currentPosition = player.currentPosition.takeIf { it != C.TIME_UNSET }
+            val updatedMediaItem = currentMediaItem.copy(
+                positionMs = currentPosition,
+                durationMs = duration,
+                videoWidth = width,
+                videoHeight = height,
+                videoRotation = rotation,
+                hasRenderedFirstFrame = true,
+                isVideoEffectsAvailable = shouldApplyVideoEffects(activeDecoderPriority),
+            )
+            player.replaceMediaItem(
+                player.currentMediaItemIndex,
+                updatedMediaItem,
+            )
+            continueDeferredStartupPreciseResume(updatedMediaItem)
+            hasRenderedFirstFrameForCurrentItem = true
+            (player as? ExoPlayer)?.let { applyVideoFilters(it, playerPreferences, force = true) }
+        }
+
+        override fun onIsPlayingChanged(isPlaying: Boolean) {
+            super.onIsPlayingChanged(isPlaying)
+            mediaSession?.run {
+                serviceScope.launch {
+                    val currentMediaItem = player.currentMediaItem ?: return@launch
+                    val playbackStateUri = currentMediaItem.resolvePlaybackStateUri()
+                    mediaRepository.updateMediumPosition(
+                        uri = playbackStateUri,
+                        position = player.currentPosition,
+                    )
+                }
+            }
+        }
+
+        override fun onRepeatModeChanged(repeatMode: Int) {
+            super.onRepeatModeChanged(repeatMode)
+            serviceScope.launch {
+                preferencesRepository.updatePlayerPreferences {
+                    it.copy(
+                        loopMode = when (repeatMode) {
+                            Player.REPEAT_MODE_OFF -> LoopMode.OFF
+                            Player.REPEAT_MODE_ONE -> LoopMode.ONE
+                            Player.REPEAT_MODE_ALL -> LoopMode.ALL
+                            else -> LoopMode.OFF
+                        },
+                    )
+                }
+            }
+        }
+
+        override fun onAudioSessionIdChanged(audioSessionId: Int) {
+            super.onAudioSessionIdChanged(audioSessionId)
+            if (audioSessionId == C.AUDIO_SESSION_ID_UNSET) {
+                releaseLoudnessEnhancer()
+                return
+            }
+            initializeLoudnessEnhancer(audioSessionId)
+        }
+
+        override fun onPlayerError(error: PlaybackException) {
+            super.onPlayerError(error)
+            Logger.error(TAG, "Player error: code=${error.errorCode} name=${error.errorCodeName}", error)
+            if (retryWithSoftwareDecoder(error)) return
+            retryWithFixedSource(error)
+        }
+    }
+
+    private fun retryWithSoftwareDecoder(error: PlaybackException): Boolean {
+        if (!isHardwareVideoDecoderError(error)) return false
+        val session = mediaSession ?: return false
+        val failedPlayer = session.player as? ExoPlayer ?: return false
+        val mediaId = failedPlayer.currentMediaItem?.mediaId ?: return false
+        if (!softwareDecoderRetried.add(mediaId)) return false
+        val mediaItems = (0 until failedPlayer.mediaItemCount).map { failedPlayer.getMediaItemAt(it) }
+        if (mediaItems.isEmpty()) return false
+
+        val currentIndex = failedPlayer.currentMediaItemIndex.coerceIn(0, mediaItems.lastIndex)
+        val playbackPosition = failedPlayer.currentPosition.coerceAtLeast(0L)
+        val shouldPlayWhenReady = failedPlayer.playWhenReady
+        val playbackParameters = failedPlayer.playbackParameters
+        val trackSelectionParameters = failedPlayer.trackSelectionParameters
+        val shuffleModeEnabled = failedPlayer.shuffleModeEnabled
+        val repeatMode = failedPlayer.repeatMode
+        val isSkipSilenceEnabled = failedPlayer.isSkipSilenceEnabledForPlayer
+        val subtitleDelayMilliseconds = failedPlayer.playerSpecificSubtitleDelayMilliseconds
+        val subtitleSpeed = failedPlayer.playerSpecificSubtitleSpeed
+        val retryPlayer = createPlayer(
+            decoderPriority = DecoderPriority.PREFER_APP,
+            assHandler = assHandler ?: return false,
+        )
+        Logger.debug(TAG, "Retrying playback with software decoder: $mediaId")
+
+        retryPlayer.setMediaItems(mediaItems, currentIndex, playbackPosition)
+        retryPlayer.restoreRuntimeState(
+            trackSelectionParameters = trackSelectionParameters,
+            shuffleModeEnabled = shuffleModeEnabled,
+            repeatMode = repeatMode,
+            isSkipSilenceEnabled = isSkipSilenceEnabled,
+            subtitleDelayMilliseconds = subtitleDelayMilliseconds,
+            subtitleSpeed = subtitleSpeed,
+            playbackParameters = playbackParameters,
+            mediaItemIndex = currentIndex,
+            positionMs = playbackPosition,
+        )
+        retryPlayer.playWhenReady = shouldPlayWhenReady
+
+        releaseLoudnessEnhancer()
+        failedPlayer.removeListener(playbackStateListener)
+        failedPlayer.removeAnalyticsListener(startupAnalyticsListener)
+        session.player = retryPlayer
+        retryPlayer.prepare()
+        failedPlayer.clearMediaItems()
+        failedPlayer.stop()
+        failedPlayer.release()
+        updateCurrentVideoEffectsAvailability(retryPlayer)
+        return true
+    }
+
+    private fun ExoPlayer.restoreRuntimeState(
+        trackSelectionParameters: TrackSelectionParameters,
+        shuffleModeEnabled: Boolean,
+        repeatMode: Int,
+        isSkipSilenceEnabled: Boolean,
+        subtitleDelayMilliseconds: Long,
+        subtitleSpeed: Float,
+        playbackParameters: androidx.media3.common.PlaybackParameters,
+        mediaItemIndex: Int,
+        positionMs: Long,
+    ) {
+        this.trackSelectionParameters = trackSelectionParameters
+        this.shuffleModeEnabled = shuffleModeEnabled
+        this.repeatMode = repeatMode
+        this.isSkipSilenceEnabledForPlayer = isSkipSilenceEnabled
+        this.playerSpecificSubtitleDelayMilliseconds = subtitleDelayMilliseconds
+        this.playerSpecificSubtitleSpeed = subtitleSpeed
+        setPlaybackParameters(playbackParameters)
+        seekTo(mediaItemIndex, positionMs)
+    }
+
+    private fun switchPlayerDecoderPriority(decoderPriority: DecoderPriority) {
+        if (decoderPriority == activeDecoderPriority) return
+        val session = mediaSession ?: return
+        val currentPlayer = session.player as? ExoPlayer ?: return
+        val mediaItems = (0 until currentPlayer.mediaItemCount).map { currentPlayer.getMediaItemAt(it) }
+        if (mediaItems.isEmpty()) {
+            Logger.info(TAG, "Switch decoder to ${decoderPriority.logName()} without active media items")
+            val nextPlayer = createPlayer(
+                decoderPriority = decoderPriority,
+                assHandler = assHandler ?: return,
+            )
+            releaseLoudnessEnhancer()
+            currentPlayer.removeListener(playbackStateListener)
+            currentPlayer.removeAnalyticsListener(startupAnalyticsListener)
+            session.player = nextPlayer
+            currentPlayer.release()
+            return
+        }
+
+        val currentIndex = currentPlayer.currentMediaItemIndex.coerceIn(0, mediaItems.lastIndex)
+        val playbackPosition = currentPlayer.currentPosition.coerceAtLeast(0L)
+        val shouldPlayWhenReady = currentPlayer.playWhenReady
+        val playbackParameters = currentPlayer.playbackParameters
+        val trackSelectionParameters = currentPlayer.trackSelectionParameters
+        val shuffleModeEnabled = currentPlayer.shuffleModeEnabled
+        val repeatMode = currentPlayer.repeatMode
+        val isSkipSilenceEnabled = currentPlayer.isSkipSilenceEnabledForPlayer
+        val subtitleDelayMilliseconds = currentPlayer.playerSpecificSubtitleDelayMilliseconds
+        val subtitleSpeed = currentPlayer.playerSpecificSubtitleSpeed
+        val currentDecoderPriority = activeDecoderPriority
+        val nextPlayer = createPlayer(
+            decoderPriority = decoderPriority,
+            assHandler = assHandler ?: return,
+        )
+        Logger.info(
+            TAG,
+            "Switch decoder from ${currentDecoderPriority.logName()} to ${decoderPriority.logName()} at index=$currentIndex position=$playbackPosition",
+        )
+
+        nextPlayer.setMediaItems(mediaItems, currentIndex, playbackPosition)
+        nextPlayer.restoreRuntimeState(
+            trackSelectionParameters = trackSelectionParameters,
+            shuffleModeEnabled = shuffleModeEnabled,
+            repeatMode = repeatMode,
+            isSkipSilenceEnabled = isSkipSilenceEnabled,
+            subtitleDelayMilliseconds = subtitleDelayMilliseconds,
+            subtitleSpeed = subtitleSpeed,
+            playbackParameters = playbackParameters,
+            mediaItemIndex = currentIndex,
+            positionMs = playbackPosition,
+        )
+        nextPlayer.playWhenReady = shouldPlayWhenReady
+
+        releaseLoudnessEnhancer()
+        currentPlayer.removeListener(playbackStateListener)
+        currentPlayer.removeAnalyticsListener(startupAnalyticsListener)
+        session.player = nextPlayer
+        nextPlayer.prepare()
+        currentPlayer.clearMediaItems()
+        currentPlayer.stop()
+        currentPlayer.release()
+        updateCurrentVideoEffectsAvailability(nextPlayer)
+    }
+
+    private fun isHardwareVideoDecoderError(error: PlaybackException): Boolean {
+        if (!activeDecoderPriority.shouldRetryWithSoftwareDecoder()) return false
+        val exoError = error as? ExoPlaybackException ?: return false
+        if (exoError.type != ExoPlaybackException.TYPE_RENDERER) return false
+        if (exoError.rendererFormat?.sampleMimeType?.startsWith("video/") != true) return false
+        val rendererException = exoError.rendererException
+        if (rendererException !is MediaCodecRenderer.DecoderInitializationException && rendererException.cause == null) return false
+        return true
+    }
+
+    private fun retryWithFixedSource(error: PlaybackException) {
+        if (!hasParserExceptionCause(error)) return
+        val player = mediaSession?.player as? ExoPlayer ?: return
+        val currentItem = player.currentMediaItem ?: return
+        if (!mediaParserRetried.add(currentItem.mediaId)) return
+
+        val mediaId = currentItem.mediaId
+        serviceScope.launch {
+            val uri = mediaId.toUri()
+            val skipRegion = withContext(Dispatchers.IO) { detectDuplicateMoov(uri) }
+
+            withContext(Dispatchers.Main) {
+                val currentPlayer = mediaSession?.player as? ExoPlayer ?: return@withContext
+                if (currentPlayer.playerError == null) return@withContext
+
+                val index = (0 until currentPlayer.mediaItemCount).firstOrNull {
+                    currentPlayer.getMediaItemAt(it).mediaId == mediaId
+                } ?: return@withContext
+
+                val item = currentPlayer.getMediaItemAt(index)
+                val dataSourceFactory = if (skipRegion != null) {
+                    Logger.debug(
+                        TAG,
+                        "Duplicate moov at ${skipRegion.start}+${skipRegion.length}, retrying: $mediaId",
+                    )
+                    DataSource.Factory {
+                        GapSkipDataSource(
+                            upstream = DefaultDataSource.Factory(applicationContext)
+                                .createDataSource(),
+                            targetUri = uri,
+                            gapStart = skipRegion.start,
+                            gapLength = skipRegion.length,
+                        )
+                    }
+                } else {
+                    Logger.debug(TAG, "Retrying with lenient extractor: $mediaId")
+                    DefaultDataSource.Factory(applicationContext)
+                }
+
+                val mediaSource = DefaultMediaSourceFactory(
+                    dataSourceFactory,
+                    LenientExtractorsFactory(),
+                ).createMediaSource(item)
+
+                currentPlayer.removeMediaItem(index)
+                currentPlayer.addMediaSource(index, mediaSource)
+                currentPlayer.seekTo(index, 0)
+                currentPlayer.prepare()
+                currentPlayer.playWhenReady = true
+            }
+        }
+    }
+
+    private fun hasParserExceptionCause(error: PlaybackException): Boolean {
+        var cause: Throwable? = error.cause
+        repeat(3) {
+            val current = cause ?: return false
+            if (current is ParserException) return true
+            cause = current.cause
+        }
+        return false
+    }
+
+    private data class SkipRegion(val start: Long, val length: Long)
+
+    private fun createPlaybackExtractorsFactory(
+        assSubtitleParserFactory: AssSubtitleParserFactory,
+        assHandler: AssHandler,
+        shouldUseFastStart: Boolean,
+    ): ExtractorsFactory {
+        val baseFactory = DefaultExtractorsFactory()
+        return ExtractorsFactory {
+            val extractors = baseFactory.createExtractors()
+            for (i in extractors.indices) {
+                if (extractors[i] is MatroskaExtractor) {
+                    extractors[i] = NormalizingAssMatroskaExtractor(
+                        assSubtitleParserFactory,
+                        assHandler,
+                    ).also { extractor ->
+                        if (shouldUseFastStart) {
+                            disableSeekForCues(extractor)
+                        }
+                    }
+                }
+            }
+            extractors
+        }
+    }
+
+    private fun createMediaSourceFactory(
+        assSubtitleParserFactory: AssSubtitleParserFactory,
+        assHandler: AssHandler,
+        shouldUseFastStart: Boolean,
+    ): DefaultMediaSourceFactory = DefaultMediaSourceFactory(
+        DefaultDataSource.Factory(applicationContext),
+        createPlaybackExtractorsFactory(
+            assSubtitleParserFactory = assSubtitleParserFactory,
+            assHandler = assHandler,
+            shouldUseFastStart = shouldUseFastStart,
+        ),
+    ).setSubtitleParserFactory(assSubtitleParserFactory)
+
+    private fun disableSeekForCues(extractor: MatroskaExtractor) {
+        try {
+            val field = MatroskaExtractor::class.java.getDeclaredField("seekForCuesEnabled")
+            field.isAccessible = true
+            field.set(extractor, false)
+        } catch (e: Exception) {
+            Logger.error(TAG, "disableSeekForCues failed", e)
+        }
+    }
+
+    private fun warmUpCodecCache() {
+        val mimeTypes = listOf(
+            MimeTypes.VIDEO_H265,
+            MimeTypes.VIDEO_H264,
+            MimeTypes.AUDIO_AAC,
+        )
+        for (mimeType in mimeTypes) {
+            try {
+                MediaCodecUtil.getDecoderInfos(mimeType, false, false)
+            } catch (_: MediaCodecUtil.DecoderQueryException) {
+            }
+        }
+    }
+
+    private fun detectDuplicateMoov(uri: Uri): SkipRegion? {
+        try {
+            contentResolver.openInputStream(uri)?.use { stream ->
+                var offset = 0L
+                var hasSeenFirstMoov = false
+                val header = ByteArray(8)
+
+                while (true) {
+                    if (!readFully(stream, header)) break
+
+                    val size = ((header[0].toLong() and 0xFF) shl 24) or
+                        ((header[1].toLong() and 0xFF) shl 16) or
+                        ((header[2].toLong() and 0xFF) shl 8) or
+                        (header[3].toLong() and 0xFF)
+                    val type = String(header, 4, 4, Charsets.US_ASCII)
+
+                    if (size < 8) break
+
+                    if (type == "moov") {
+                        if (hasSeenFirstMoov) {
+                            return SkipRegion(start = offset, length = size)
+                        }
+                        hasSeenFirstMoov = true
+                    }
+
+                    if (type == "mdat") break
+
+                    val bodySize = size - 8
+                    var skipped = 0L
+                    while (skipped < bodySize) {
+                        val s = stream.skip(bodySize - skipped)
+                        if (s <= 0) break
+                        skipped += s
+                    }
+                    if (skipped < bodySize) break
+                    offset += size
+                }
+            }
+        } catch (e: Exception) {
+            Logger.error(TAG, "Failed to scan MP4 structure", e)
+        }
+        return null
+    }
+
+    private class GapSkipDataSource(
+        private val upstream: DataSource,
+        private val targetUri: Uri,
+        private val gapStart: Long,
+        private val gapLength: Long,
+    ) : DataSource by upstream {
+
+        private var isTarget = false
+        private var hasCrossedGap = false
+        private var bytesUntilGap = Long.MAX_VALUE
+        private var currentDataSpec: DataSpec? = null
+
+        override fun open(dataSpec: DataSpec): Long {
+            currentDataSpec = dataSpec
+            isTarget = dataSpec.uri == targetUri
+            if (!isTarget) return upstream.open(dataSpec)
+
+            val virtualPos = dataSpec.position
+            if (virtualPos >= gapStart) {
+                hasCrossedGap = true
+                bytesUntilGap = Long.MAX_VALUE
+                val adjustedSpec = dataSpec.buildUpon()
+                    .setPosition(virtualPos + gapLength)
+                    .build()
+                return upstream.open(adjustedSpec)
+            }
+
+            hasCrossedGap = false
+            bytesUntilGap = gapStart - virtualPos
+            val length = upstream.open(dataSpec)
+            if (length == C.LENGTH_UNSET.toLong()) return length
+
+            val physicalEnd = virtualPos + length
+            return when {
+                physicalEnd > gapStart + gapLength -> length - gapLength
+                physicalEnd > gapStart -> gapStart - virtualPos
+                else -> length
+            }
+        }
+
+        override fun read(buffer: ByteArray, offset: Int, length: Int): Int {
+            if (!isTarget) return upstream.read(buffer, offset, length)
+
+            if (!hasCrossedGap && bytesUntilGap <= 0L) {
+                upstream.close()
+                upstream.open(
+                    DataSpec.Builder()
+                        .setUri(currentDataSpec!!.uri)
+                        .setPosition(gapStart + gapLength)
+                        .build(),
+                )
+                hasCrossedGap = true
+            }
+
+            val toRead = if (!hasCrossedGap) {
+                minOf(length.toLong(), bytesUntilGap).toInt()
+            } else {
+                length
+            }
+            val bytesRead = upstream.read(buffer, offset, toRead)
+            if (bytesRead > 0 && !hasCrossedGap) {
+                bytesUntilGap -= bytesRead
+            }
+            return bytesRead
+        }
+
+        override fun close() {
+            isTarget = false
+            upstream.close()
+        }
+    }
+
+    private class LenientExtractorsFactory : ExtractorsFactory {
+        override fun createExtractors(): Array<Extractor> {
+            val defaults = DefaultExtractorsFactory().createExtractors()
+            return Array(defaults.size + 1) { i ->
+                if (i == 0) LenientMp4Extractor() else defaults[i - 1]
+            }
+        }
+    }
+
+    private class LenientMp4Extractor : Extractor {
+
+        private val delegate = Mp4Extractor(SubtitleParser.Factory.UNSUPPORTED)
+
+        override fun sniff(input: ExtractorInput): Boolean = delegate.sniff(input)
+
+        override fun init(output: ExtractorOutput) = delegate.init(output)
+
+        override fun read(input: ExtractorInput, seekPosition: PositionHolder): Int = try {
+            delegate.read(input, seekPosition)
+        } catch (e: ParserException) {
+            Logger.error(TAG, "Lenient extractor treating error as end of input", e)
+            Extractor.RESULT_END_OF_INPUT
+        }
+
+        override fun seek(position: Long, timeUs: Long) = delegate.seek(position, timeUs)
+
+        override fun release() = delegate.release()
+    }
+
+    private fun setEnhancerTargetGain(gain: Int) {
+        requestedVolumeGain = gain.coerceAtLeast(0)
+        if (loudnessEnhancer == null && playerPreferences.isVolumeBoostEnabled) {
+            val audioSessionId = mediaSession?.player?.audioSessionId ?: C.AUDIO_SESSION_ID_UNSET
+            if (audioSessionId != C.AUDIO_SESSION_ID_UNSET) {
+                initializeLoudnessEnhancer(audioSessionId)
+            }
+        }
+        applyLoudnessEnhancerGain()
+    }
+
+    private fun initializeLoudnessEnhancer(audioSessionId: Int) {
+        if (!playerPreferences.isVolumeBoostEnabled) return
+        if (audioSessionId == C.AUDIO_SESSION_ID_UNSET) return
+        try {
+            releaseLoudnessEnhancer()
+            loudnessEnhancer = LoudnessEnhancer(audioSessionId)
+            Logger.debug(TAG, "Loudness enhancer initialized: boost=true")
+            applyLoudnessEnhancerGain()
+        } catch (e: Exception) {
+            Logger.error(TAG, "Failed to initialize loudness enhancer", e)
+            loudnessEnhancer = null
+        }
+    }
+
+    private fun releaseLoudnessEnhancer() {
+        val enhancer = loudnessEnhancer ?: return
+        try {
+            enhancer.enabled = false
+        } catch (_: Exception) {
+        }
+        try {
+            enhancer.release()
+        } catch (_: Exception) {
+        } finally {
+            loudnessEnhancer = null
+        }
+    }
+
+    private fun handleRepeatedPlayback(player: Player) {
+        player.currentMediaItem?.mediaMetadata?.let { metadata ->
+            player.setPlaybackSpeed(playerPreferences.defaultPlaybackSpeed)
+            player.playerSpecificSubtitleDelayMilliseconds = metadata.subtitleDelayMilliseconds ?: 0L
+            player.playerSpecificSubtitleSpeed = metadata.subtitleSpeed ?: 1f
+        }
+    }
+
+    private fun applyVideoFilters(preferences: PlayerPreferences) {
+        val player = mediaSession?.player as? ExoPlayer ?: return
+        applyVideoFilters(player, preferences)
+    }
+
+    private fun applyVideoFilters(
+        player: ExoPlayer,
+        preferences: PlayerPreferences,
+        force: Boolean = false,
+    ) {
+        val videoFilters = preferences.toVideoFilterPreferences(screenAspectRatio)
+        scheduleVideoFilters(
+            player = player,
+            videoFilters = videoFilters,
+            delayMs = 0L,
+            shouldSkipStalePreferences = true,
+            logPrefix = "Apply",
+            force = force,
+        )
+    }
+
+    private fun previewVideoFilters(preferences: PlayerPreferences) {
+        val player = mediaSession?.player as? ExoPlayer ?: return
+        val videoFilters = preferences.toVideoFilterPreferences(screenAspectRatio)
+        scheduleVideoFilters(
+            player = player,
+            videoFilters = videoFilters,
+            delayMs = VIDEO_FILTER_PREVIEW_DELAY_MS,
+            shouldSkipStalePreferences = false,
+            logPrefix = "Preview",
+        )
+    }
+
+    private fun scheduleVideoFilters(
+        player: ExoPlayer,
+        videoFilters: VideoFilterPreferences,
+        delayMs: Long,
+        shouldSkipStalePreferences: Boolean,
+        logPrefix: String,
+        force: Boolean = false,
+    ) {
+        pendingVideoFiltersJob?.cancel()
+        if (!force && currentVideoEffectsState == VideoEffectsState(videoFilters, activeDecoderPriority, isPipelineInitialized = true)) return
+
+        pendingVideoFiltersJob = serviceScope.launch {
+            fun hasStalePreferences() = shouldSkipStalePreferences &&
+                preferencesRepository.playerPreferences.value.toVideoFilterPreferences(screenAspectRatio) != videoFilters
+
+            if (delayMs > 0L) delay(delayMs)
+            if (hasStalePreferences()) return@launch
+
+            val decoderPriority = activeDecoderPriority
+            val transition = videoFilterTransition.to(
+                targetFilters = videoFilters,
+                startMs = SystemClock.elapsedRealtime(),
+                durationMs = VIDEO_FILTER_TRANSITION_DURATION_MS,
+            )
+            if (hasStalePreferences()) return@launch
+
+            applyVideoEffects(player, videoFilters, decoderPriority, transition)
+            Logger.debug(TAG, "$logPrefix video filters: $videoFilters effect=${activeVideoFiltersEffect != null}")
+        }.also { job ->
+            job.invokeOnCompletion {
+                if (pendingVideoFiltersJob == job) pendingVideoFiltersJob = null
+            }
+        }
+    }
+
+    private fun applyVideoEffects(
+        player: ExoPlayer,
+        videoFilters: VideoFilterPreferences,
+        decoderPriority: DecoderPriority,
+        transition: VideoFilterTransition,
+    ) {
+        val effect = activeVideoFiltersEffect
+        val canUpdateActiveEffect = effect != null &&
+            shouldUseVideoFiltersEffect(
+                filters = videoFilters,
+                decoderPriority = decoderPriority,
+            )
+        if (canUpdateActiveEffect) {
+            videoFilterTransition = transition
+            effect.updateTransition(transition)
+            currentVideoEffectsState = VideoEffectsState(
+                filters = videoFilters,
+                decoderPriority = decoderPriority,
+                isPipelineInitialized = true,
+            )
+            refreshPausedVideoFrame(player)
+            updateCurrentVideoEffectsAvailability(player)
+            return
+        }
+
+        val effects = buildVideoEffects(
+            transition = transition,
+            decoderPriority = decoderPriority,
+        )
+        if (!hasRenderedFirstFrameForCurrentItem && activeVideoFiltersEffect == null && effects.isNotEmpty()) {
+            Logger.debug(TAG, "Defer setVideoEffects until first frame to resolve HDR state")
+            return
+        }
+        if (effects.isEmpty() && activeVideoFiltersEffect == null) {
+            currentVideoEffectsState = VideoEffectsState(
+                filters = videoFilters,
+                decoderPriority = decoderPriority,
+                isPipelineInitialized = false,
+            )
+            Logger.debug(TAG, "Skip setVideoEffects: no filters and pipeline not initialized")
+            updateCurrentVideoEffectsAvailability(player)
+            return
+        }
+        videoFilterTransition = if (effects.isEmpty()) VideoFilterTransition.default() else transition
+        currentVideoEffectsState = VideoEffectsState(
+            filters = videoFilters,
+            decoderPriority = decoderPriority,
+            isPipelineInitialized = true,
+        )
+        activeVideoFiltersEffect = effects.filterIsInstance<VideoFiltersEffect>().firstOrNull()
+        player.setVideoEffects(effects)
+        refreshPausedVideoFrame(player)
+        updateCurrentVideoEffectsAvailability(player)
+    }
+
+    private fun refreshPausedVideoFrame(player: ExoPlayer) {
+        if (player.playWhenReady) return
+        if (player.playbackState != Player.STATE_READY) return
+        val position = player.currentPosition.takeIf { it != C.TIME_UNSET } ?: return
+        val duration = player.duration.takeIf { it != C.TIME_UNSET && it > 0L }
+        val targetPosition = duration
+            ?.let { (position + PAUSED_FRAME_REFRESH_OFFSET_MS).coerceAtMost(it) }
+            ?.takeIf { it != position }
+            ?: (position - PAUSED_FRAME_REFRESH_OFFSET_MS).coerceAtLeast(0L)
+        if (targetPosition == position) return
+        player.seekTo(targetPosition)
+        player.seekTo(position)
+    }
+
+    private fun updateCurrentVideoEffectsAvailability(player: ExoPlayer) {
+        val currentMediaItem = player.currentMediaItem ?: return
+        val isVideoEffectsAvailable = shouldApplyVideoEffects(activeDecoderPriority)
+        if (currentMediaItem.mediaMetadata.isVideoEffectsAvailable == isVideoEffectsAvailable) return
+
+        player.replaceMediaItem(
+            player.currentMediaItemIndex,
+            currentMediaItem.copy(isVideoEffectsAvailable = isVideoEffectsAvailable),
+        )
+        Logger.debug(TAG, "Video effects availability: available=$isVideoEffectsAvailable decoder=$activeDecoderPriority")
+    }
+
+    private fun PlayerPreferences.toVideoFilterPreferences(screenAspectRatio: Float): VideoFilterPreferences {
+        if (!shouldApplyVideoFilters && !isAmbienceModeEnabled) return VideoFilterPreferences.default()
+
+        val filters = VideoFilterPreferences(
+            shouldApply = shouldApplyVideoFilters || isAmbienceModeEnabled,
+            isAmbienceModeEnabled = isAmbienceModeEnabled,
+            screenAspectRatio = screenAspectRatio,
+            isBrightnessEnabled = isVideoBrightnessFilterEnabled,
+            brightness = if (isVideoBrightnessFilterEnabled) {
+                videoBrightness.coerceIn(PlayerPreferences.MIN_VIDEO_BRIGHTNESS, PlayerPreferences.MAX_VIDEO_BRIGHTNESS)
+            } else {
+                PlayerPreferences.DEFAULT_VIDEO_BRIGHTNESS
+            },
+            isContrastEnabled = isVideoContrastFilterEnabled,
+            contrast = if (isVideoContrastFilterEnabled) {
+                videoContrast.coerceIn(PlayerPreferences.MIN_VIDEO_CONTRAST, PlayerPreferences.MAX_VIDEO_CONTRAST)
+            } else {
+                PlayerPreferences.DEFAULT_VIDEO_CONTRAST
+            },
+            isSaturationEnabled = isVideoSaturationFilterEnabled,
+            saturation = if (isVideoSaturationFilterEnabled) {
+                videoSaturation.coerceIn(PlayerPreferences.MIN_VIDEO_SATURATION, PlayerPreferences.MAX_VIDEO_SATURATION)
+            } else {
+                PlayerPreferences.DEFAULT_VIDEO_SATURATION
+            },
+            isHueEnabled = isVideoHueFilterEnabled,
+            hue = if (isVideoHueFilterEnabled) {
+                videoHue.coerceIn(PlayerPreferences.MIN_VIDEO_HUE, PlayerPreferences.MAX_VIDEO_HUE)
+            } else {
+                PlayerPreferences.DEFAULT_VIDEO_HUE
+            },
+            isGammaEnabled = isVideoGammaFilterEnabled,
+            gamma = if (isVideoGammaFilterEnabled) {
+                videoGamma.coerceIn(PlayerPreferences.MIN_VIDEO_GAMMA, PlayerPreferences.MAX_VIDEO_GAMMA)
+            } else {
+                PlayerPreferences.DEFAULT_VIDEO_GAMMA
+            },
+            isSharpeningEnabled = isVideoSharpeningFilterEnabled,
+            sharpening = if (isVideoSharpeningFilterEnabled) {
+                videoSharpening.coerceIn(PlayerPreferences.DEFAULT_VIDEO_SHARPENING, PlayerPreferences.MAX_VIDEO_SHARPENING)
+            } else {
+                PlayerPreferences.DEFAULT_VIDEO_SHARPENING
+            },
+        )
+        return if (filters.shouldCreateEffect()) filters else VideoFilterPreferences.default()
+    }
+
+    private fun Bundle.toPlayerPreferences(): PlayerPreferences = PlayerPreferences(
+        shouldApplyVideoFilters = getBoolean(CustomCommands.SHOULD_APPLY_VIDEO_FILTERS_KEY, false),
+        isVideoBrightnessFilterEnabled = getBoolean(CustomCommands.IS_VIDEO_BRIGHTNESS_FILTER_ENABLED_KEY, false),
+        videoBrightness = getFloat(CustomCommands.VIDEO_BRIGHTNESS_KEY, PlayerPreferences.DEFAULT_VIDEO_BRIGHTNESS),
+        isVideoContrastFilterEnabled = getBoolean(CustomCommands.IS_VIDEO_CONTRAST_FILTER_ENABLED_KEY, false),
+        videoContrast = getFloat(CustomCommands.VIDEO_CONTRAST_KEY, PlayerPreferences.DEFAULT_VIDEO_CONTRAST),
+        isVideoSaturationFilterEnabled = getBoolean(CustomCommands.IS_VIDEO_SATURATION_FILTER_ENABLED_KEY, false),
+        videoSaturation = getFloat(CustomCommands.VIDEO_SATURATION_KEY, PlayerPreferences.DEFAULT_VIDEO_SATURATION),
+        isVideoHueFilterEnabled = getBoolean(CustomCommands.IS_VIDEO_HUE_FILTER_ENABLED_KEY, false),
+        videoHue = getFloat(CustomCommands.VIDEO_HUE_KEY, PlayerPreferences.DEFAULT_VIDEO_HUE),
+        isVideoGammaFilterEnabled = getBoolean(CustomCommands.IS_VIDEO_GAMMA_FILTER_ENABLED_KEY, false),
+        videoGamma = getFloat(CustomCommands.VIDEO_GAMMA_KEY, PlayerPreferences.DEFAULT_VIDEO_GAMMA),
+        isVideoSharpeningFilterEnabled = getBoolean(CustomCommands.IS_VIDEO_SHARPENING_FILTER_ENABLED_KEY, false),
+        videoSharpening = getFloat(CustomCommands.VIDEO_SHARPENING_KEY, PlayerPreferences.DEFAULT_VIDEO_SHARPENING),
+    )
+
+    private fun buildVideoEffects(
+        transition: VideoFilterTransition,
+        decoderPriority: DecoderPriority,
+    ): List<Effect> {
+        if (!shouldUseVideoFiltersEffect(transition.targetFilters, decoderPriority)) return emptyList()
+        return listOf(
+            VideoFiltersEffect(
+                transition = transition,
+                transitionDurationMs = VIDEO_FILTER_TRANSITION_DURATION_MS,
+            ),
+        )
+    }
+
+    private fun shouldUseVideoFiltersEffect(
+        filters: VideoFilterPreferences,
+        decoderPriority: DecoderPriority,
+    ): Boolean = shouldApplyVideoEffects(decoderPriority) && !isCurrentVideoHdr && filters.shouldCreateEffect()
+
+    private fun applyLoudnessEnhancerGain() {
+        val enhancer = loudnessEnhancer ?: return
+        val gain = requestedVolumeGain
+
+        try {
+            enhancer.setTargetGain(gain)
+            enhancer.enabled = gain > 0
+            Logger.debug(TAG, "Apply loudness gain: requested=$requestedVolumeGain, enabled=${gain > 0}")
+        } catch (e: Exception) {
+            Logger.error(TAG, "Failed to apply loudness enhancer gain", e)
+        }
+    }
+
+    private val mediaSessionCallback = object : MediaSession.Callback {
+        override fun onConnect(
+            session: MediaSession,
+            controller: MediaSession.ControllerInfo,
+        ): MediaSession.ConnectionResult {
+            val connectionResult = super.onConnect(session, controller)
+            return MediaSession.ConnectionResult.accept(
+                connectionResult.availableSessionCommands
+                    .buildUpon()
+                    .addSessionCommands(customCommands)
+                    .build(),
+                connectionResult.availablePlayerCommands,
+            )
+        }
+
+        override fun onSetMediaItems(
+            mediaSession: MediaSession,
+            controller: MediaSession.ControllerInfo,
+            mediaItems: MutableList<MediaItem>,
+            startIndex: Int,
+            startPositionMs: Long,
+        ): ListenableFuture<MediaSession.MediaItemsWithStartPosition> = serviceScope.future(Dispatchers.Default) {
+            preciseSeekMediaIds.clear()
+            val updatedMediaItems = updatedMediaItemsWithMetadata(mediaItems)
+            prepareCachedPreciseSeekMediaItems(updatedMediaItems)
+            loadArtworkInBackground(updatedMediaItems)
+            return@future MediaSession.MediaItemsWithStartPosition(updatedMediaItems, startIndex, startPositionMs)
+        }
+
+        override fun onAddMediaItems(
+            mediaSession: MediaSession,
+            controller: MediaSession.ControllerInfo,
+            mediaItems: MutableList<MediaItem>,
+        ): ListenableFuture<MutableList<MediaItem>> = serviceScope.future(Dispatchers.Default) {
+            val updatedMediaItems = updatedMediaItemsWithMetadata(mediaItems)
+            prepareCachedPreciseSeekMediaItems(updatedMediaItems)
+            loadArtworkInBackground(updatedMediaItems)
+            return@future updatedMediaItems.toMutableList()
+        }
+
+        override fun onCustomCommand(
+            session: MediaSession,
+            controller: MediaSession.ControllerInfo,
+            customCommand: SessionCommand,
+            args: Bundle,
+        ): ListenableFuture<SessionResult> = serviceScope.future {
+            val command = CustomCommands.fromSessionCommand(customCommand)
+                ?: return@future SessionResult(SessionError.ERROR_BAD_VALUE)
+
+            when (command) {
+                CustomCommands.ADD_SUBTITLE_TRACK -> {
+                    val subtitleUriString = args.getString(CustomCommands.SUBTITLE_TRACK_URI_KEY)
+                    if (subtitleUriString.isNullOrBlank()) {
+                        Logger.info(TAG, "Add subtitle track rejected: empty uri")
+                        return@future SessionResult(SessionError.ERROR_BAD_VALUE)
+                    }
+                    val subtitleUri = subtitleUriString.toUri()
+                    val player = mediaSession?.player
+                    if (player == null) {
+                        Logger.info(TAG, "Add subtitle track rejected: player unavailable")
+                        return@future SessionResult(SessionError.ERROR_BAD_VALUE)
+                    }
+                    val currentMediaItem = player.currentMediaItem
+                    if (currentMediaItem == null) {
+                        Logger.info(TAG, "Add subtitle track rejected: current media item unavailable")
+                        return@future SessionResult(SessionError.ERROR_BAD_VALUE)
+                    }
+
+                    val newSubConfiguration = uriToSubtitleConfiguration(
+                        uri = subtitleUri,
+                        subtitleEncoding = playerPreferences.subtitleTextEncoding,
+                    )
+                    val playbackStateUri = currentMediaItem.resolvePlaybackStateUri()
+                    mediaRepository.updateMediumPosition(
+                        uri = playbackStateUri,
+                        position = player.currentPosition,
+                    )
+                    mediaRepository.addExternalSubtitleToMedium(
+                        uri = playbackStateUri,
+                        subtitleUri = subtitleUri,
+                    )
+                    player.addAdditionalSubtitleConfiguration(newSubConfiguration)
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+
+                CustomCommands.PRECISE_SEEK_TO -> {
+                    val targetPositionMs = args.getLong(CustomCommands.SEEK_POSITION_MS_KEY, C.TIME_UNSET)
+                    if (targetPositionMs == C.TIME_UNSET) {
+                        return@future SessionResult(SessionError.ERROR_BAD_VALUE)
+                    }
+                    return@future requestSeekForCurrentItem(targetPositionMs)
+                }
+
+                CustomCommands.SET_SKIP_SILENCE_ENABLED -> {
+                    val isSkipSilenceEnabled = args.getBoolean(CustomCommands.SKIP_SILENCE_ENABLED_KEY)
+                    mediaSession?.player?.isSkipSilenceEnabledForPlayer = isSkipSilenceEnabled
+                    mediaSession?.sessionExtras = Bundle().apply {
+                        putBoolean(CustomCommands.SKIP_SILENCE_ENABLED_KEY, isSkipSilenceEnabled)
+                    }
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+
+                CustomCommands.GET_SKIP_SILENCE_ENABLED -> {
+                    val isSkipSilenceEnabled = mediaSession?.player?.isSkipSilenceEnabledForPlayer ?: false
+                    return@future SessionResult(
+                        SessionResult.RESULT_SUCCESS,
+                        Bundle().apply {
+                            putBoolean(CustomCommands.SKIP_SILENCE_ENABLED_KEY, isSkipSilenceEnabled)
+                        },
+                    )
+                }
+
+                CustomCommands.SET_IS_SCRUBBING_MODE_ENABLED -> {
+                    val isScrubbingModeEnabled = args.getBoolean(CustomCommands.IS_SCRUBBING_MODE_ENABLED_KEY)
+                    mediaSession?.player?.setIsScrubbingModeEnabled(isScrubbingModeEnabled)
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+
+                CustomCommands.SET_PERSISTENT_PLAYBACK_SPEED -> {
+                    val playbackSpeed = args.getFloat(CustomCommands.PLAYBACK_SPEED_KEY)
+                    val player = mediaSession?.player
+                        ?: return@future SessionResult(SessionError.ERROR_BAD_VALUE)
+                    player.setPlaybackSpeed(playbackSpeed)
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+
+                CustomCommands.SET_TRANSIENT_PLAYBACK_SPEED -> {
+                    val playbackSpeed = args.getFloat(CustomCommands.PLAYBACK_SPEED_KEY)
+                    val player = mediaSession?.player
+                        ?: return@future SessionResult(SessionError.ERROR_BAD_VALUE)
+                    player.setPlaybackSpeed(playbackSpeed)
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+
+                CustomCommands.IS_LOUDNESS_GAIN_SUPPORTED -> {
+                    val isSupported = loudnessEnhancer != null
+                    return@future SessionResult(
+                        SessionResult.RESULT_SUCCESS,
+                        Bundle().apply {
+                            putBoolean(CustomCommands.IS_LOUDNESS_GAIN_SUPPORTED_KEY, isSupported)
+                        },
+                    )
+                }
+
+                CustomCommands.SET_LOUDNESS_GAIN -> {
+                    val gain = args.getInt(CustomCommands.LOUDNESS_GAIN_KEY, 0)
+                    setEnhancerTargetGain(gain)
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+
+                CustomCommands.GET_LOUDNESS_GAIN -> {
+                    return@future SessionResult(
+                        SessionResult.RESULT_SUCCESS,
+                        Bundle().apply {
+                            putInt(CustomCommands.LOUDNESS_GAIN_KEY, requestedVolumeGain)
+                        },
+                    )
+                }
+
+                CustomCommands.PREVIEW_VIDEO_FILTERS -> {
+                    previewVideoFilters(args.toPlayerPreferences())
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+
+                CustomCommands.SET_SCREEN_ASPECT_RATIO -> {
+                    val aspectRatio = args.getFloat(CustomCommands.SCREEN_ASPECT_RATIO_KEY, 0f)
+                    if (aspectRatio > 0f && aspectRatio != screenAspectRatio) {
+                        screenAspectRatio = aspectRatio
+                        applyVideoFilters(playerPreferences)
+                    }
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+
+                CustomCommands.GET_SUBTITLE_DELAY -> {
+                    val subtitleDelay = mediaSession?.player?.playerSpecificSubtitleDelayMilliseconds ?: 0
+                    return@future SessionResult(
+                        SessionResult.RESULT_SUCCESS,
+                        Bundle().apply {
+                            putLong(CustomCommands.SUBTITLE_DELAY_KEY, subtitleDelay)
+                        },
+                    )
+                }
+
+                CustomCommands.SET_SUBTITLE_DELAY -> {
+                    val subtitleDelay = args.getLong(CustomCommands.SUBTITLE_DELAY_KEY)
+                    mediaSession?.player?.playerSpecificSubtitleDelayMilliseconds = subtitleDelay
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+
+                CustomCommands.GET_SUBTITLE_SPEED -> {
+                    val subtitleSpeed = mediaSession?.player?.playerSpecificSubtitleSpeed ?: 0f
+                    return@future SessionResult(
+                        SessionResult.RESULT_SUCCESS,
+                        Bundle().apply {
+                            putFloat(CustomCommands.SUBTITLE_SPEED_KEY, subtitleSpeed)
+                        },
+                    )
+                }
+
+                CustomCommands.SET_SUBTITLE_SPEED -> {
+                    val subtitleSpeed = args.getFloat(CustomCommands.SUBTITLE_SPEED_KEY)
+                    mediaSession?.player?.playerSpecificSubtitleSpeed = subtitleSpeed
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+
+                CustomCommands.STOP_PLAYER_SESSION -> {
+                    mediaSession?.run {
+                        serviceScope.launch {
+                            val currentMediaItem = player.currentMediaItem ?: return@launch
+                            val playbackStateUri = currentMediaItem.resolvePlaybackStateUri()
+                            mediaRepository.updateMediumPosition(
+                                uri = playbackStateUri,
+                                position = player.currentPosition,
+                            )
+                        }
+                        player.clearMediaItems()
+                        player.stop()
+                    }
+                    stopSelf()
+                    return@future SessionResult(SessionResult.RESULT_SUCCESS)
+                }
+            }
+        }
+    }
+
+    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? {
+        if (mediaSession == null) {
+            Logger.error(TAG, "onGetSession called but mediaSession is null")
+            return null
+        }
+        return mediaSession
+    }
+
+    private fun createPlayer(
+        decoderPriority: DecoderPriority,
+        assHandler: AssHandler,
+    ): ExoPlayer {
+        activeDecoderPriority = decoderPriority
+        val extensionRendererMode = decoderPriority.extensionRendererMode()
+        val shouldEnableDecoderFallback = decoderPriority.shouldEnableDecoderFallback()
+        val shouldUseAudioExtensionFallback = decoderPriority.shouldUseAudioExtensionFallback()
+
+        val renderersFactory = NormalizingRenderersFactory(
+            context = applicationContext,
+            volumeNormalizationAudioProcessor = volumeNormalizationAudioProcessor,
+            shouldUseAudioExtensionFallback = shouldUseAudioExtensionFallback,
+        )
+            .setEnableDecoderFallback(shouldEnableDecoderFallback)
+            .setExtensionRendererMode(extensionRendererMode)
+
+        val preferences = playerPreferences
+        val trackSelector = DefaultTrackSelector(applicationContext).apply {
+            setParameters(
+                buildUponParameters()
+                    .setPreferredAudioLanguage(preferences.preferredAudioLanguage)
+                    .setPreferredTextLanguage(preferences.preferredSubtitleLanguage),
+            )
+        }
+
+        return ExoPlayer.Builder(applicationContext)
+            .setMediaSourceFactory(sessionMediaSourceFactory)
+            .setRenderersFactory(renderersFactory.withAssSupport(assHandler))
+            .setTrackSelector(trackSelector)
+            .setAudioAttributes(
+                AudioAttributes.Builder()
+                    .setUsage(C.USAGE_MEDIA)
+                    .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
+                    .build(),
+                preferences.shouldRequireAudioFocus,
+            )
+            .setHandleAudioBecomingNoisy(preferences.shouldPauseOnHeadsetDisconnect)
+            .build()
+            .also {
+                assHandler.init(it)
+                it.addListener(playbackStateListener)
+                it.addAnalyticsListener(startupAnalyticsListener)
+                it.pauseAtEndOfMediaItems = !preferences.shouldAutoPlay
+                it.repeatMode = when (preferences.loopMode) {
+                    LoopMode.OFF -> Player.REPEAT_MODE_OFF
+                    LoopMode.ONE -> Player.REPEAT_MODE_ONE
+                    LoopMode.ALL -> Player.REPEAT_MODE_ALL
+                }
+                currentVideoEffectsState = VideoEffectsState(
+                    filters = VideoFilterPreferences.default(),
+                    decoderPriority = activeDecoderPriority,
+                )
+                activeVideoFiltersEffect = null
+                applyVideoFilters(it, preferences)
+            }
+    }
+
+    override fun onCreate() {
+        try {
+            super.onCreate()
+            serviceScope.launch(Dispatchers.IO) { warmUpCodecCache() }
+            serviceScope.launch {
+                preferencesRepository.playerPreferences
+                    .distinctUntilChanged { old, new -> old.decoderPriority == new.decoderPriority }
+                    .collect { preferences -> switchPlayerDecoderPriority(preferences.decoderPriority) }
+            }
+            serviceScope.launch {
+                preferencesRepository.playerPreferences
+                    .distinctUntilChanged { old, new ->
+                        old.toVideoFilterPreferences(screenAspectRatio) == new.toVideoFilterPreferences(screenAspectRatio)
+                    }
+                    .collect(::applyVideoFilters)
+            }
+            serviceScope.launch {
+                preferencesRepository.playerPreferences
+                    .distinctUntilChanged { old, new -> old.isVolumeBoostEnabled == new.isVolumeBoostEnabled }
+                    .collect { preferences ->
+                        if (preferences.isVolumeBoostEnabled) {
+                            val audioSessionId = mediaSession?.player?.audioSessionId ?: return@collect
+                            initializeLoudnessEnhancer(audioSessionId)
+                        } else {
+                            releaseLoudnessEnhancer()
+                        }
+                    }
+            }
+            serviceScope.launch {
+                preferencesRepository.playerPreferences
+                    .distinctUntilChanged { old, new -> old.isVolumeNormalizationEnabled == new.isVolumeNormalizationEnabled }
+                    .collect { preferences ->
+                        volumeNormalizationAudioProcessor.isEnabled = preferences.isVolumeNormalizationEnabled
+                    }
+            }
+            volumeNormalizationAudioProcessor.isEnabled = playerPreferences.isVolumeNormalizationEnabled
+            val assHandler = AssHandler(renderType = AssRenderType.OVERLAY_CANVAS)
+            this.assHandler = assHandler
+            AssHandlerRegistry.register(assHandler)
+            val assSubtitleParserFactory = AssSubtitleParserFactory(assHandler)
+            this.assSubtitleParserFactory = assSubtitleParserFactory
+            fastStartMediaSourceFactory = createMediaSourceFactory(
+                assSubtitleParserFactory = assSubtitleParserFactory,
+                assHandler = assHandler,
+                shouldUseFastStart = true,
+            )
+            preciseSeekMediaSourceFactory = createMediaSourceFactory(
+                assSubtitleParserFactory = assSubtitleParserFactory,
+                assHandler = assHandler,
+                shouldUseFastStart = false,
+            )
+            sessionMediaSourceFactory = object : MediaSource.Factory {
+                override fun setDrmSessionManagerProvider(drmSessionManagerProvider: DrmSessionManagerProvider): MediaSource.Factory {
+                    sessionDrmSessionManagerProvider = drmSessionManagerProvider
+                    return this
+                }
+
+                override fun setLoadErrorHandlingPolicy(loadErrorHandlingPolicy: LoadErrorHandlingPolicy): MediaSource.Factory {
+                    sessionLoadErrorHandlingPolicy = loadErrorHandlingPolicy
+                    return this
+                }
+
+                override fun getSupportedTypes(): IntArray = fastStartMediaSourceFactory.supportedTypes
+
+                override fun createMediaSource(mediaItem: MediaItem): MediaSource = this@ExoPlayerService.createMediaSource(mediaItem)
+            }
+
+            val player = createPlayer(
+                decoderPriority = playerPreferences.decoderPriority,
+                assHandler = assHandler,
+            )
+
+            try {
+                mediaSession = MediaSession.Builder(this, player).apply {
+                    setSessionActivity(
+                        PendingIntent.getActivity(
+                            this@ExoPlayerService,
+                            0,
+                            Intent(this@ExoPlayerService, ExoPlayerActivity::class.java),
+                            PendingIntent.FLAG_IMMUTABLE,
+                        ),
+                    )
+                    setCallback(mediaSessionCallback)
+                    setCustomLayout(
+                        listOf(
+                            CommandButton.Builder(ICON_UNDEFINED)
+                                .setCustomIconResId(app.gyrolet.mpvrx.R.drawable.ic_close)
+                                .setDisplayName("Stop")
+                                .setSessionCommand(CustomCommands.STOP_PLAYER_SESSION.sessionCommand)
+                                .setEnabled(true)
+                                .build(),
+                        ),
+                    )
+                }.build()
+            } catch (e: Exception) {
+                Logger.error(TAG, "Failed to create media session", e)
+            }
+        } catch (e: Exception) {
+            Logger.error(TAG, "Error in onCreate", e)
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        releaseLoudnessEnhancer()
+        pendingPreciseSeekPromotionJob?.cancel()
+        pendingPreciseSeekPromotionJob = null
+        preciseSeekRequestId++
+        assHandler?.let(AssHandlerRegistry::unregister)
+        assHandler = null
+        mediaSession?.run {
+            player.clearMediaItems()
+            player.stop()
+            player.removeListener(playbackStateListener)
+            player.release()
+            release()
+            mediaSession = null
+        }
+        subtitleCacheDir.deleteFiles()
+        mkvCueParseJobs.clear()
+        mediaParserRetried.clear()
+        softwareDecoderRetried.clear()
+        serviceScope.cancel()
+    }
+
+    private fun prepareCachedPreciseSeekMediaItems(mediaItems: List<MediaItem>) {
+        mediaItems.forEach { mediaItem ->
+            if (!mediaItem.mediaMetadata.isApproximateSeekEnabled) return@forEach
+            restoreCachedMkvSeekMap(mediaItem)?.let { seekMap ->
+                mkvSeekMapCache[mediaItem.mediaId] = seekMap
+                preciseSeekMediaIds.add(mediaItem.mediaId)
+            }
+        }
+    }
+
+    private suspend fun updatedMediaItemsWithMetadata(
+        mediaItems: List<MediaItem>,
+    ): List<MediaItem> = supervisorScope {
+        mediaItems.map { mediaItem ->
+            async {
+                val uri = mediaItem.mediaId.toUri()
+                val playbackStateUri = mediaItem.resolvePlaybackStateUri()
+                val primaryVideoState = mediaRepository.getVideoState(uri = playbackStateUri)
+                val video = mediaRepository.getVideoByUri(uri = playbackStateUri)
+
+                val validExternalSubs = (primaryVideoState?.externalSubs ?: emptyList()).filter { subUri ->
+                    if (subUri.scheme in DIRECT_SUBTITLE_URI_SCHEMES) return@filter true
+                    try {
+                        contentResolver.openInputStream(subUri)?.close()
+                        true
+                    } catch (_: Exception) {
+                        false
+                    }
+                }
+                validExternalSubs.forEach(onlineSubtitleRepository::touchSubtitle)
+                val existingSubConfigurations = mediaItem.localConfiguration?.subtitleConfigurations ?: emptyList()
+                val restoredSubConfigurations = validExternalSubs.map { subtitleUri ->
+                    async {
+                        uriToSubtitleConfiguration(
+                            uri = subtitleUri,
+                            subtitleEncoding = playerPreferences.subtitleTextEncoding,
+                        )
+                    }
+                }.awaitAll()
+                val mergedSubConfigurations = mergeSubtitleConfigurations(
+                    existing = existingSubConfigurations,
+                    incoming = restoredSubConfigurations,
+                )
+
+                val title = mediaItem.mediaMetadata.title ?: video?.nameWithExtension ?: getFilenameFromUri(uri)
+                val positionMs = mediaItem.mediaMetadata.positionMs ?: primaryVideoState?.position
+                val durationMs = mediaItem.mediaMetadata.durationMs
+                    ?: video?.duration?.takeIf { it > 0L }
+                    ?: extractDurationMs(uri)
+                val videoScale = mediaItem.mediaMetadata.videoZoom ?: primaryVideoState?.videoScale
+                val audioTrackIndex = mediaItem.mediaMetadata.audioTrackIndex ?: primaryVideoState?.audioTrackIndex
+                val subtitleTrackIndex = mediaItem.mediaMetadata.subtitleTrackIndex ?: primaryVideoState?.subtitleTrackIndex
+                val subtitleDelay = mediaItem.mediaMetadata.subtitleDelayMilliseconds ?: primaryVideoState?.subtitleDelayMilliseconds
+                val subtitleSpeed = mediaItem.mediaMetadata.subtitleSpeed ?: primaryVideoState?.subtitleSpeed
+                
+                val mediaPath = video?.path ?: primaryVideoState?.path ?: getPath(uri) ?: uri.path
+                val isLocalUri = uri.scheme == ContentResolver.SCHEME_FILE || uri.scheme == ContentResolver.SCHEME_CONTENT
+                val isApproximateSeekEnabled = isLocalUri && mediaPath?.endsWith(".mkv", ignoreCase = true) == true
+
+                mediaItem.buildUpon().apply {
+                    setSubtitleConfigurations(mergedSubConfigurations)
+                    setMediaMetadata(
+                        MediaMetadata.Builder().apply {
+                            setTitle(title)
+                            setDurationMs(durationMs)
+                            setMetadataExtras(
+                                positionMs = positionMs,
+                                videoScale = videoScale,
+                                audioTrackIndex = audioTrackIndex,
+                                subtitleTrackIndex = subtitleTrackIndex,
+                                subtitleDelayMilliseconds = subtitleDelay,
+                                subtitleSpeed = subtitleSpeed,
+                                isApproximateSeekEnabled = isApproximateSeekEnabled,
+                                isVideoEffectsAvailable = shouldApplyVideoEffects(activeDecoderPriority),
+                                requestHeaders = mediaItem.mediaMetadata.requestHeaders,
+                                remoteServerId = mediaItem.mediaMetadata.remoteServerId,
+                                remoteFilePath = mediaItem.mediaMetadata.remoteFilePath,
+                                remoteProtocol = mediaItem.mediaMetadata.remoteProtocol,
+                            )
+                        }.build(),
+                    )
+                }.build()
+            }
+        }.awaitAll()
+    }
+
+    private fun extractDurationMs(uri: Uri): Long? {
+        var retriever: MediaMetadataRetriever? = null
+        return try {
+            retriever = MediaMetadataRetriever()
+            retriever.setDataSource(applicationContext, uri)
+            retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toLongOrNull()
+        } catch (_: Exception) {
+            null
+        } finally {
+            retriever?.release()
+        }
+    }
+
+    private fun createMediaSource(mediaItem: MediaItem): MediaSource {
+        val requestHeaders = mediaItem.mediaMetadata.requestHeaders
+        val uri = mediaItem.localConfiguration?.uri
+        val dataSourceFactory = createDataSourceFactory(uri, requestHeaders)
+        val cachedSeekMap = mkvSeekMapCache[mediaItem.mediaId]
+        val shouldUseFastStart = mediaItem.mediaMetadata.isApproximateSeekEnabled && mediaItem.mediaId !in preciseSeekMediaIds
+        if (cachedSeekMap != null && !shouldUseFastStart) {
+            val factory = DefaultMediaSourceFactory(
+                dataSourceFactory,
+                createSeekMapInjectedExtractorsFactory(cachedSeekMap),
+            ).setSubtitleParserFactory(assSubtitleParserFactory)
+            sessionLoadErrorHandlingPolicy?.let(factory::setLoadErrorHandlingPolicy)
+            sessionDrmSessionManagerProvider?.let(factory::setDrmSessionManagerProvider)
+            return factory.createMediaSource(mediaItem)
+        }
+
+        val currentAssHandler = assHandler
+        if (currentAssHandler != null) {
+            val mediaSourceFactory = DefaultMediaSourceFactory(
+                dataSourceFactory,
+                createPlaybackExtractorsFactory(
+                    assSubtitleParserFactory = assSubtitleParserFactory,
+                    assHandler = currentAssHandler,
+                    shouldUseFastStart = shouldUseFastStart,
+                ),
+            ).setSubtitleParserFactory(assSubtitleParserFactory)
+            sessionLoadErrorHandlingPolicy?.let(mediaSourceFactory::setLoadErrorHandlingPolicy)
+            sessionDrmSessionManagerProvider?.let(mediaSourceFactory::setDrmSessionManagerProvider)
+            return mediaSourceFactory.createMediaSource(mediaItem)
+        }
+
+        return DefaultMediaSourceFactory(dataSourceFactory)
+            .apply {
+                sessionLoadErrorHandlingPolicy?.let(::setLoadErrorHandlingPolicy)
+                sessionDrmSessionManagerProvider?.let(::setDrmSessionManagerProvider)
+            }
+            .setSubtitleParserFactory(assSubtitleParserFactory)
+            .createMediaSource(mediaItem)
+    }
+
+    private fun createDataSourceFactory(
+        uri: Uri?,
+        requestHeaders: Map<String, String>,
+    ): DataSource.Factory {
+        if (uri?.scheme == "smb") {
+            val username = requestHeaders["_smb_username"].orEmpty()
+            val password = requestHeaders["_smb_password"].orEmpty()
+            return SmbDataSource.Factory(username, password)
+        }
+        if (uri?.scheme == "ftp") {
+            val username = requestHeaders["_ftp_username"].orEmpty()
+            val password = requestHeaders["_ftp_password"].orEmpty()
+            return FtpDataSource.Factory(username, password)
+        }
+
+        val httpHeaders = requestHeaders.filterKeys { !it.startsWith("_") }
+        if (httpHeaders.isEmpty()) {
+            return DefaultDataSource.Factory(applicationContext)
+        }
+
+        val okHttpClient = OkHttpClient.Builder()
+            .followRedirects(true)
+            .followSslRedirects(true)
+            .build()
+        val httpFactory = OkHttpDataSource.Factory(okHttpClient)
+            .setDefaultRequestProperties(httpHeaders)
+        return DefaultDataSource.Factory(applicationContext, httpFactory)
+    }
+
+    private suspend fun promoteCurrentItemToPreciseSeek(
+        targetPositionMs: Long,
+        requestId: Long = ++preciseSeekRequestId,
+    ): SessionResult {
+        val player = mediaSession?.player as? ExoPlayer ?: return SessionResult(SessionError.ERROR_BAD_VALUE)
+        val initialItem = player.currentMediaItem ?: return SessionResult(SessionError.ERROR_BAD_VALUE)
+        val maxPosition = initialItem.mediaMetadata.durationMs ?: player.duration.takeIf { it != C.TIME_UNSET }
+        val targetPosition = maxPosition?.let { targetPositionMs.coerceIn(0L, it) } ?: targetPositionMs.coerceAtLeast(0L)
+
+        if (!initialItem.mediaMetadata.isApproximateSeekEnabled || initialItem.mediaId in preciseSeekMediaIds) {
+            player.seekTo(targetPosition)
+            return SessionResult(SessionResult.RESULT_SUCCESS)
+        }
+
+        val seekMap = mkvSeekMapCache[initialItem.mediaId]
+            ?: withContext(Dispatchers.IO) { scheduleMkvCueCache(initialItem).await() }
+        if (requestId != preciseSeekRequestId) {
+            return SessionResult(SessionError.ERROR_BAD_VALUE)
+        }
+
+        val currentItem = player.currentMediaItem ?: return SessionResult(SessionError.ERROR_BAD_VALUE)
+        val currentIndex = player.currentMediaItemIndex
+        if (currentItem.mediaId != initialItem.mediaId) {
+            return SessionResult(SessionError.ERROR_BAD_VALUE)
+        }
+        if (seekMap == null) {
+            player.seekTo(targetPosition)
+            return SessionResult(SessionResult.RESULT_SUCCESS)
+        }
+        mkvSeekMapCache[currentItem.mediaId] = seekMap
+
+        val updatedMediaItem = currentItem.copy(
+            positionMs = targetPosition,
+            isApproximateSeekEnabled = false,
+        )
+        preciseSeekMediaIds.add(currentItem.mediaId)
+        val shouldPlayWhenReady = player.playWhenReady
+        player.addMediaSource(currentIndex + 1, createMediaSource(updatedMediaItem))
+        player.seekTo(currentIndex + 1, targetPosition)
+        player.removeMediaItem(currentIndex)
+        player.prepare()
+        player.playWhenReady = shouldPlayWhenReady
+        return SessionResult(SessionResult.RESULT_SUCCESS)
+    }
+
+    private suspend fun MediaItem.resolvePlaybackStateUri(): String = mediaRepository.getCanonicalMediaUri(
+        uri = buildRemotePlaybackStateKey(
+            remoteProtocol = mediaMetadata.remoteProtocol,
+            remoteServerId = mediaMetadata.remoteServerId,
+            remoteFilePath = mediaMetadata.remoteFilePath,
+        ) ?: mediaId,
+    )
+
+    private suspend fun requestSeekForCurrentItem(targetPositionMs: Long): SessionResult {
+        val player = mediaSession?.player as? ExoPlayer ?: return SessionResult(SessionError.ERROR_BAD_VALUE)
+        val currentItem = player.currentMediaItem ?: return SessionResult(SessionError.ERROR_BAD_VALUE)
+        val maxPosition = currentItem.mediaMetadata.durationMs ?: player.duration.takeIf { it != C.TIME_UNSET }
+        val targetPosition = maxPosition?.let { targetPositionMs.coerceIn(0L, it) } ?: targetPositionMs.coerceAtLeast(0L)
+
+        if (!currentItem.mediaMetadata.isApproximateSeekEnabled) {
+            player.seekTo(targetPosition)
+            return SessionResult(SessionResult.RESULT_SUCCESS)
+        }
+
+        val startPosition = player.currentPosition.takeIf { it != C.TIME_UNSET } ?: 0L
+        val startDelta = kotlin.math.abs(targetPosition - startPosition)
+        if (startDelta < FAST_SEEK_MIN_DELTA_MS) {
+            return SessionResult(SessionResult.RESULT_SUCCESS)
+        }
+
+        return promoteCurrentItemToPreciseSeek(targetPosition)
+    }
+
+    private fun scheduleMkvCueCache(mediaItem: MediaItem): Deferred<androidx.media3.extractor.SeekMap?> {
+        val mediaId = mediaItem.mediaId
+        mkvSeekMapCache[mediaId]?.let { return CompletableDeferred(it) }
+        mkvCueParseJobs[mediaId]?.let { return it }
+
+        val restoredSeekMap = restoreCachedMkvSeekMap(mediaItem)
+        if (restoredSeekMap != null) {
+            mkvSeekMapCache[mediaId] = restoredSeekMap
+            return CompletableDeferred(restoredSeekMap)
+        }
+
+        val durationMs = mediaItem.mediaMetadata.durationMs ?: return CompletableDeferred(null)
+        val uri = Uri.parse(mediaId)
+
+        val parseJob = serviceScope.async(Dispatchers.IO) {
+            val cuePoints = MkvCuesParser.parse(applicationContext, uri)
+            if (cuePoints == null) return@async null
+
+            val durationUs = durationMs * 1_000L
+            val seekMap = buildSeekMapFromCues(cuePoints, durationUs)
+            mkvSeekMapCache[mediaId] = seekMap
+            persistMkvSeekMap(uri, cuePoints, durationUs)
+            seekMap
+        }
+        parseJob.invokeOnCompletion {
+            mkvCueParseJobs.remove(mediaId, parseJob)
+        }
+        mkvCueParseJobs[mediaId] = parseJob
+        return parseJob
+    }
+
+    private fun continueDeferredStartupPreciseResume(currentMediaItem: MediaItem) {
+        val player = mediaSession?.player ?: return
+        val mediaId = currentMediaItem.mediaId
+        if (pendingStartupPreciseResumeToken != mediaId) return
+
+        val targetPosition = pendingStartupPreciseResumePositionMs ?: currentMediaItem.mediaMetadata.positionMs ?: return
+        if (targetPosition < STARTUP_PRECISE_RESUME_THRESHOLD_MS) return
+        if (player.currentPosition >= targetPosition - 1_000L) return
+
+        pendingPreciseSeekPromotionJob?.cancel()
+        pendingPreciseSeekPromotionJob = serviceScope.launch(Dispatchers.IO) {
+            val seekMap = mkvSeekMapCache[mediaId]
+                ?: restoreCachedMkvSeekMap(currentMediaItem)
+                ?: scheduleMkvCueCache(currentMediaItem).await()
+                ?: return@launch
+
+            mkvSeekMapCache[mediaId] = seekMap
+            withContext(Dispatchers.Main) {
+                val currentPlayer = mediaSession?.player ?: return@withContext
+                val current = currentPlayer.currentMediaItem ?: return@withContext
+                if (current.mediaId != mediaId) return@withContext
+                pendingStartupPreciseResumeToken = null
+                pendingStartupPreciseResumePositionMs = null
+                promoteCurrentItemToPreciseSeek(targetPosition)
+            }
+        }
+    }
+
+    private fun mkvCueCacheFile(uri: Uri): File? {
+        val path = runCatching {
+            when (uri.scheme) {
+                ContentResolver.SCHEME_FILE -> uri.toFile().absolutePath
+                ContentResolver.SCHEME_CONTENT -> getPath(uri)
+                else -> null
+            }
+        }.getOrNull() ?: return null
+        val sourceFile = File(path)
+        if (!sourceFile.exists()) return null
+        val cacheKey = sourceFile.absolutePath.hashCode().toUInt().toString(16)
+        val cacheDir = File(cacheDir, "mkv-cues")
+        if (!cacheDir.exists()) cacheDir.mkdirs()
+        return File(cacheDir, "mkv-cues-$cacheKey.bin")
+    }
+
+    private fun persistMkvSeekMap(uri: Uri, cuePoints: List<app.gyrolet.mpvrx.exoplayer.feature.player.engine.media3.MkvCuePoint>, durationUs: Long) {
+        val sourceFile = resolveLocalFile(uri) ?: return
+        val cacheFile = mkvCueCacheFile(uri) ?: return
+        runCatching {
+            DataOutputStream(cacheFile.outputStream().buffered()).use { output ->
+                output.writeInt(MKV_CUES_CACHE_MAGIC)
+                output.writeLong(sourceFile.length())
+                output.writeLong(sourceFile.lastModified())
+                output.writeLong(durationUs)
+                output.writeInt(cuePoints.size)
+                cuePoints.forEach { cuePoint ->
+                    output.writeLong(cuePoint.timeUs)
+                    output.writeLong(cuePoint.clusterPosition)
+                }
+            }
+        }
+    }
+
+    private fun restoreCachedMkvSeekMap(mediaItem: MediaItem): androidx.media3.extractor.SeekMap? {
+        val uri = Uri.parse(mediaItem.mediaId)
+        val sourceFile = resolveLocalFile(uri) ?: return null
+        val cacheFile = mkvCueCacheFile(uri) ?: return null
+        if (!cacheFile.exists()) return null
+
+        return runCatching {
+            DataInputStream(cacheFile.inputStream().buffered()).use { input ->
+                val magic = input.readInt()
+                if (magic != MKV_CUES_CACHE_MAGIC) return@runCatching null
+                val fileSize = input.readLong()
+                val lastModified = input.readLong()
+                if (fileSize != sourceFile.length() || lastModified != sourceFile.lastModified()) {
+                    return@runCatching null
+                }
+                val durationUs = input.readLong()
+                val count = input.readInt()
+                val cuePoints = List(count) {
+                    app.gyrolet.mpvrx.exoplayer.feature.player.engine.media3.MkvCuePoint(
+                        timeUs = input.readLong(),
+                        clusterPosition = input.readLong(),
+                    )
+                }
+                buildSeekMapFromCues(cuePoints, durationUs)
+            }
+        }.getOrNull()
+    }
+
+    private fun resolveLocalFile(uri: Uri): File? = when (uri.scheme) {
+        ContentResolver.SCHEME_FILE -> runCatching { uri.toFile() }.getOrNull()
+        ContentResolver.SCHEME_CONTENT -> getPath(uri)?.let(::File)
+        else -> null
+    }?.takeIf(File::exists)
+
+    private fun createSeekMapInjectedExtractorsFactory(
+        seekMap: androidx.media3.extractor.SeekMap,
+    ): ExtractorsFactory = ExtractorsFactory {
+        val baseFactory = DefaultExtractorsFactory()
+        val extractors = baseFactory.createExtractors()
+        for (i in extractors.indices) {
+            if (extractors[i] is MatroskaExtractor) {
+                val assExtractor = NormalizingAssMatroskaExtractor(assSubtitleParserFactory, assHandler!!)
+                disableSeekForCues(assExtractor)
+                extractors[i] = SeekMapInjectingExtractor(assExtractor, seekMap)
+            }
+        }
+        extractors
+    }
+
+    private suspend fun loadArtworkForUri(uri: Uri): ByteArray? = try {
+        val result = imageLoader.execute(
+            ImageRequest.Builder(this@ExoPlayerService)
+                .data(uri)
+                .build(),
+        )
+        (result as? SuccessResult)?.image?.toBitmap()?.toByteArray()
+    } catch (_: Exception) {
+        null
+    }
+
+    private suspend fun findMediaItemInSession(mediaId: String): Triple<Player, Int, MediaItem>? = withContext(
+        Dispatchers.Main.immediate,
+    ) {
+        val player = mediaSession?.player ?: return@withContext null
+        val index = (0 until player.mediaItemCount).firstOrNull {
+            player.getMediaItemAt(it).mediaId == mediaId
+        } ?: return@withContext null
+        Triple(player, index, player.getMediaItemAt(index))
+    }
+
+    private fun loadArtworkInBackground(mediaItems: List<MediaItem>) {
+        serviceScope.launch(Dispatchers.Default) {
+            mediaItems.forEach { mediaItem ->
+                launch {
+                    val artworkData = loadArtworkForUri(mediaItem.mediaId.toUri()) ?: return@launch
+
+                    withContext(Dispatchers.Main) {
+                        val (player, index, currentMediaItem) = findMediaItemInSession(mediaItem.mediaId) ?: return@withContext
+                        val updatedMediaItem = currentMediaItem.buildUpon()
+                            .setMediaMetadata(
+                                currentMediaItem.mediaMetadata.buildUpon()
+                                    .setArtworkUri(null)
+                                    .setArtworkData(artworkData, MediaMetadata.PICTURE_TYPE_FRONT_COVER)
+                                    .build(),
+                            )
+                            .build()
+                        player.replaceMediaItem(index, updatedMediaItem)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun loadExternalSubtitlesForCurrentItem(
+        mediaId: String,
+        requestHeaders: Map<String, String>,
+    ) {
+        serviceScope.launch(Dispatchers.IO) {
+            val configurations = buildExternalSubtitleConfigurations(mediaId, requestHeaders)
+            if (configurations.isEmpty()) return@launch
+
+            withContext(Dispatchers.Main) {
+                val (player, index, currentMediaItem) = findMediaItemInSession(mediaId) ?: return@withContext
+                val existingConfigs = currentMediaItem.localConfiguration?.subtitleConfigurations ?: emptyList()
+                val mergedConfigs = mergeSubtitleConfigurations(existingConfigs, configurations)
+                if (mergedConfigs.size == existingConfigs.size) return@withContext
+
+                val updatedMediaItem = currentMediaItem.buildUpon()
+                    .setSubtitleConfigurations(mergedConfigs)
+                    .build()
+                val currentPosition = player.currentPosition
+                val shouldPlayWhenReady = player.playWhenReady
+                isPendingExternalSubAutoSelect = true
+                player.addMediaItem(index + 1, updatedMediaItem)
+                player.seekTo(index + 1, currentPosition)
+                player.playWhenReady = shouldPlayWhenReady
+                player.removeMediaItem(index)
+            }
+        }
+    }
+
+    private suspend fun buildExternalSubtitleConfigurations(
+        mediaId: String,
+        requestHeaders: Map<String, String>,
+    ): List<MediaItem.SubtitleConfiguration> = coroutineScope {
+        val uri = mediaId.toUri()
+        val playbackStateUri = mediaRepository.getCanonicalMediaUri(uri = mediaId)
+        val video = mediaRepository.getVideoByUri(uri = playbackStateUri)
+        val primaryVideoState = mediaRepository.getVideoState(uri = playbackStateUri)
+        val dbExternalSubs = primaryVideoState?.externalSubs ?: emptyList()
+
+        val localSubs = (video?.path ?: getPath(uri))?.let {
+            File(it).getLocalSubtitles(
+                context = this@ExoPlayerService,
+                excludeSubsList = dbExternalSubs,
+            )
+        } ?: emptyList()
+
+        val allExternalSubs = dbExternalSubs + localSubs
+        if (allExternalSubs.isEmpty()) return@coroutineScope emptyList()
+
+        allExternalSubs.map { subtitleUri ->
+            async {
+                uriToSubtitleConfiguration(
+                    uri = subtitleUri,
+                    subtitleEncoding = playerPreferences.subtitleTextEncoding,
+                )
+            }
+        }.awaitAll()
+    }
+
+    private fun mergeSubtitleConfigurations(
+        existing: List<MediaItem.SubtitleConfiguration>,
+        incoming: List<MediaItem.SubtitleConfiguration>,
+    ): List<MediaItem.SubtitleConfiguration> {
+        val mergedById = LinkedHashMap<String, MediaItem.SubtitleConfiguration>()
+        existing.forEach { subtitleConfiguration ->
+            mergedById[subtitleConfiguration.id ?: subtitleConfiguration.uri.toString()] = subtitleConfiguration
+        }
+        incoming.forEach { subtitleConfiguration ->
+            mergedById[subtitleConfiguration.id ?: subtitleConfiguration.uri.toString()] = subtitleConfiguration
+        }
+        return mergedById.values.toList()
+    }
+
+    private fun findBestSubtitleTrackIndex(textTracks: List<Tracks.Group>): Int {
+        val preferred = playerPreferences.preferredSubtitleLanguage
+        if (preferred.isBlank()) return 0
+
+        val normalizedPref = normalizeLanguageTag(preferred)
+        for (i in textTracks.indices) {
+            val format = textTracks[i].getTrackFormat(0)
+            if (matchesPreferredLanguage(format, normalizedPref)) return i
+        }
+        return 0
+    }
+
+    private fun matchesPreferredLanguage(format: Format, preferred: String): Boolean {
+        val trackLang = format.language?.let(::normalizeLanguageTag) ?: return false
+
+        if (preferred.startsWith("zh-") && (trackLang == "zh" || trackLang.startsWith("zh-"))) {
+            return matchesChineseVariantByLabel(format.label, preferred)
+        }
+
+        return trackLang.startsWith(preferred) || preferred.startsWith(trackLang)
+    }
+
+    private fun matchesChineseVariantByLabel(label: String?, preferred: String): Boolean {
+        if (label == null) return preferred == "zh"
+        val lower = label.lowercase()
+        val isSimplified = preferred.contains("hans") || preferred.contains("cn")
+        val isTraditional = preferred.contains("hant") || preferred.contains("tw") || preferred.contains("hk")
+
+        return when {
+            isSimplified -> lower.containsAny("简", "chs", "simplified")
+            isTraditional -> lower.containsAny("繁", "cht", "traditional")
+            else -> true
+        }
+    }
+
+    private fun normalizeLanguageTag(tag: String): String {
+        val lower = tag.lowercase().replace('_', '-')
+        return ISO_639_2T_TO_1[lower] ?: ISO_639_2T_TO_1[lower.substringBefore('-')]?.let {
+            it + lower.removePrefix(lower.substringBefore('-'))
+        } ?: lower
+    }
+
+    private fun String.containsAny(vararg keywords: String): Boolean = keywords.any { contains(it, ignoreCase = true) }
+
+    private fun Bitmap.toByteArray(): ByteArray {
+        val stream = ByteArrayOutputStream()
+        compress(Bitmap.CompressFormat.JPEG, 100, stream)
+        return stream.toByteArray()
+    }
+}
+
+private fun readFully(stream: InputStream, buffer: ByteArray): Boolean {
+    var pos = 0
+    while (pos < buffer.size) {
+        val read = stream.read(buffer, pos, buffer.size - pos)
+        if (read < 0) return false
+        pos += read
+    }
+    return true
+}
+
+@get:UnstableApi
+@set:UnstableApi
+private var Player.isSkipSilenceEnabledForPlayer: Boolean
+    get() = when (this) {
+        is ExoPlayer -> this.skipSilenceEnabled
+        else -> false
+    }
+    set(value) {
+        when (this) {
+            is ExoPlayer -> this.skipSilenceEnabled = value
+        }
+    }
+
+@get:UnstableApi
+@set:UnstableApi
+private var Player.playerSpecificSubtitleDelayMilliseconds: Long
+    get() = when (this) {
+        is ExoPlayer -> this.subtitleDelayMilliseconds
+        else -> 0L
+    }
+    set(value) {
+        when (this) {
+            is ExoPlayer -> this.subtitleDelayMilliseconds = value
+        }
+    }
+
+@get:UnstableApi
+@set:UnstableApi
+private var Player.playerSpecificSubtitleSpeed: Float
+    get() = when (this) {
+        is ExoPlayer -> this.subtitleSpeed
+        else -> 0f
+    }
+    set(value) {
+        when (this) {
+            is ExoPlayer -> this.subtitleSpeed = value
+        }
+    }
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/MediaPlayerScreen.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/MediaPlayerScreen.kt
new file mode 100644
index 000000000..29ff545a3
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/MediaPlayerScreen.kt
@@ -0,0 +1,857 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player
+
+import android.content.res.Configuration
+import android.graphics.BitmapFactory
+import android.view.KeyEvent
+import android.widget.Toast
+import androidx.activity.compose.BackHandler
+import androidx.annotation.OptIn
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.displayCutoutPadding
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.FilledTonalButton
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.blur
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Shadow
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LifecycleEventEffect
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import java.util.Locale
+import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.delay
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.ExternalSubtitleFontSource
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControl
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControlZone
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControlsStyle
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerIconStyle
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.noRippleClickable
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.seekByRequestedOffset
+import app.gyrolet.mpvrx.exoplayer.feature.player.input.PlayerKeyboardController
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.previewVideoFilters
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.setScreenAspectRatio
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.ControlsVisibilityState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.VerticalGesture
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberBrightnessState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberControlsVisibilityState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberErrorState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberMediaPresentationState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberMetadataState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberPictureInPictureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberRotationState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberSeekGestureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberSleepTimerState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberTapGestureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberVideoZoomAndContentScaleState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberVolumeAndBrightnessGestureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberVolumeState
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.AudioTrackSelectorContent
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.DecoderPrioritySelectorContent
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.DeviceStatsOverlay
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.DoubleTapIndicator
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.MenuOverlayView
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.MenuRootContent
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.MenuRoute
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.OverlayShowView
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.OverlayView
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.PlaybackSpeedSelectorContent
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.PlaylistContent
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.SleepTimerSelectorContent
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.SubtitleConfiguration
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.SubtitleSelectorContent
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.VerticalProgressView
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.VideoContentScaleSelectorContent
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.ExoPlayerControls
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.VideoFiltersPanel
+
+private const val TAG = "MediaPlayerScreen"
+
+val LocalControlsVisibilityState = compositionLocalOf<ControlsVisibilityState?> { null }
+val LocalPlayerIconStyle = compositionLocalOf { PlayerIconStyle.TONAL }
+
+internal data class LongPressOverlayUiState(
+    val speedText: String,
+)
+
+internal fun resolveLongPressOverlayUiState(
+    isLongPressGestureInAction: Boolean,
+    isDebugLongPressOverlayVisible: Boolean,
+    longPressSpeed: Float,
+    shouldShowOverlay: Boolean,
+): LongPressOverlayUiState? {
+    if (!shouldShowOverlay && !isDebugLongPressOverlayVisible) return null
+    if (!isLongPressGestureInAction && !isDebugLongPressOverlayVisible) return null
+
+    return LongPressOverlayUiState(
+        speedText = String.format(Locale.US, "%.1fx", longPressSpeed),
+    )
+}
+
+@OptIn(UnstableApi::class)
+@Composable
+internal fun MediaPlayerScreen(
+    player: Player?,
+    viewModel: PlayerViewModel,
+    playerPreferences: PlayerPreferences,
+    externalSubtitleFontSource: ExternalSubtitleFontSource?,
+    modifier: Modifier = Modifier,
+    onSelectSubtitleClick: () -> Unit,
+    onAddOnlineSubtitleClick: (String) -> Unit,
+    onBackClick: () -> Unit,
+    onPlayInBackgroundClick: () -> Unit,
+    isTakingScreenshot: Boolean = false,
+    onScreenshotClick: () -> Unit,
+    onKeyboardEventHandlerChanged: ((KeyEvent) -> Boolean) -> Unit = {},
+) {
+    val volumeState = rememberVolumeState(
+        player = player,
+        shouldShowVolumePanelIfHeadsetIsOn = playerPreferences.shouldShowSystemVolumePanel,
+        isVolumeBoostEnabled = playerPreferences.isVolumeBoostEnabled,
+    )
+    player ?: return
+    val metadataState = rememberMetadataState(player)
+    val mediaPresentationState = rememberMediaPresentationState(player)
+    val controlsVisibilityState = rememberControlsVisibilityState(
+        player = player,
+        hideAfter = playerPreferences.controllerAutoHideTimeout.seconds,
+    )
+    val tapGestureState = rememberTapGestureState(
+        player = player,
+        doubleTapGesture = playerPreferences.doubleTapGesture,
+        seekIncrementMillis = playerPreferences.seekIncrement.seconds.inWholeMilliseconds,
+        shouldUseLongPressGesture = playerPreferences.shouldUseLongPressControls,
+        shouldUseLongPressVariableSpeed = playerPreferences.shouldUseLongPressVariableSpeed,
+        longPressSpeed = playerPreferences.longPressControlsSpeed,
+    )
+    val seekGestureState = rememberSeekGestureState(
+        player = player,
+        sensitivity = playerPreferences.seekSensitivity,
+        isSeekGestureEnabled = playerPreferences.shouldUseSeekControls,
+    )
+    val pictureInPictureState = rememberPictureInPictureState(
+        player = player,
+        shouldAutoEnter = playerPreferences.shouldAutoEnterPip,
+    )
+    val videoZoomAndContentScaleState = rememberVideoZoomAndContentScaleState(
+        player = player,
+        initialContentScale = playerPreferences.playerVideoZoom,
+        isZoomGestureEnabled = playerPreferences.shouldUseZoomControls,
+        isPanGestureEnabled = playerPreferences.isPanGestureEnabled,
+        onEvent = viewModel::onVideoZoomEvent,
+    )
+    val brightnessState = rememberBrightnessState()
+    val volumeAndBrightnessGestureState = rememberVolumeAndBrightnessGestureState(
+        volumeState = volumeState,
+        brightnessState = brightnessState,
+        isVolumeGestureEnabled = playerPreferences.isVolumeSwipeGestureEnabled,
+        isBrightnessGestureEnabled = playerPreferences.isBrightnessSwipeGestureEnabled,
+        volumeGestureSensitivity = playerPreferences.volumeGestureSensitivity,
+        brightnessGestureSensitivity = playerPreferences.brightnessGestureSensitivity,
+    )
+    val rotationState = rememberRotationState(
+        player = player,
+        screenOrientation = playerPreferences.playerScreenOrientation,
+        shouldRememberScreenOrientation = playerPreferences.shouldRememberPlayerScreenOrientation,
+        lastScreenOrientation = playerPreferences.lastPlayerScreenOrientation,
+        onLastScreenOrientationChange = viewModel::updateLastPlayerScreenOrientation,
+    )
+    var restoredVolumeMediaItemIndex by remember { mutableIntStateOf(Int.MIN_VALUE) }
+    var lastSavedVolumePercentage by remember { mutableIntStateOf(volumeState.volumePercentage) }
+    var pendingRestoredVolumePercentage by remember { mutableStateOf<Int?>(null) }
+    val errorState = rememberErrorState(player = player)
+
+    LaunchedEffect(pictureInPictureState.isInPictureInPictureMode) {
+        if (pictureInPictureState.isInPictureInPictureMode) {
+            controlsVisibilityState.hideControls()
+        }
+    }
+
+    LaunchedEffect(tapGestureState.isLongPressGestureInAction) {
+        if (tapGestureState.isLongPressGestureInAction) {
+            controlsVisibilityState.hideControls()
+        }
+    }
+
+    LifecycleEventEffect(Lifecycle.Event.ON_START) {
+        if (playerPreferences.shouldRememberPlayerBrightness) {
+            brightnessState.setBrightness(playerPreferences.playerBrightness)
+        }
+        if (playerPreferences.shouldRememberPlayerVolume && restoredVolumeMediaItemIndex != player.currentMediaItemIndex) {
+            restoredVolumeMediaItemIndex = player.currentMediaItemIndex
+            val savedVolumePercentage = playerPreferences.playerVolumePercentage
+            val restoredVolumePercentage = savedVolumePercentage.coerceAtMost(playerPreferences.maxInitialPlayerVolumePercentage)
+            Logger.debug(
+                TAG,
+                "Restore player volume: saved=$savedVolumePercentage, " +
+                    "limit=${playerPreferences.maxInitialPlayerVolumePercentage}, applied=$restoredVolumePercentage",
+            )
+            volumeState.updateVolumePercentage(restoredVolumePercentage)
+            pendingRestoredVolumePercentage = volumeState.volumePercentage
+        }
+    }
+
+    LaunchedEffect(brightnessState.currentBrightness) {
+        if (playerPreferences.shouldRememberPlayerBrightness) {
+            viewModel.updatePlayerBrightness(brightnessState.currentBrightness)
+        }
+    }
+
+    LaunchedEffect(volumeState.volumePercentage) {
+        if (!playerPreferences.shouldRememberPlayerVolume) return@LaunchedEffect
+        if (pendingRestoredVolumePercentage == volumeState.volumePercentage) {
+            pendingRestoredVolumePercentage = null
+            lastSavedVolumePercentage = volumeState.volumePercentage
+            return@LaunchedEffect
+        }
+        pendingRestoredVolumePercentage = null
+        if (lastSavedVolumePercentage == volumeState.volumePercentage) return@LaunchedEffect
+
+        lastSavedVolumePercentage = volumeState.volumePercentage
+        viewModel.updatePlayerVolume(volumeState.volumePercentage)
+    }
+
+    var overlayView by remember { mutableStateOf<OverlayView?>(null) }
+    val isModern = playerPreferences.controlsStyle == PlayerControlsStyle.MODERN
+    var menuRouteStack by remember { mutableStateOf<List<MenuRoute>>(emptyList()) }
+    val isAmbienceModeEnabled = playerPreferences.isAmbienceModeEnabled
+
+    val context = LocalContext.current
+    val configuration = LocalConfiguration.current
+
+    LaunchedEffect(configuration.screenWidthDp, configuration.screenHeightDp) {
+        val aspectRatio = configuration.screenWidthDp.toFloat() / configuration.screenHeightDp.toFloat()
+        (player as? androidx.media3.session.MediaController)?.setScreenAspectRatio(aspectRatio)
+    }
+
+    val sleepTimerState = rememberSleepTimerState(player = player)
+
+    var shouldShowOverlay by remember { mutableStateOf(false) }
+    var videoFiltersInitialPreferences by remember { mutableStateOf<PlayerPreferences?>(null) }
+    val videoFiltersUnavailableMessage = stringResource(R.string.video_filters_unavailable_software_decoder)
+
+    fun restoreVideoFiltersPreview() {
+        videoFiltersInitialPreferences?.let { initialPreferences ->
+            (player as? androidx.media3.session.MediaController)?.previewVideoFilters(initialPreferences)
+        }
+        videoFiltersInitialPreferences = null
+    }
+
+    fun overlayViewToMenuRoute(view: OverlayView): MenuRoute = when (view) {
+        OverlayView.AUDIO_SELECTOR -> MenuRoute.Audio
+        OverlayView.SUBTITLE_SELECTOR -> MenuRoute.Subtitle
+        OverlayView.PLAYBACK_SPEED -> MenuRoute.PlaybackSpeed
+        OverlayView.VIDEO_CONTENT_SCALE -> MenuRoute.VideoContentScale
+        OverlayView.VIDEO_FILTERS -> MenuRoute.VideoFilters
+        OverlayView.PLAYLIST -> MenuRoute.Playlist
+        OverlayView.SLEEP_TIMER -> MenuRoute.SleepTimer
+        OverlayView.DECODER_PRIORITY -> MenuRoute.Decoder
+    }
+
+    fun openOverlayPanel(target: OverlayView) {
+        controlsVisibilityState.hideControls()
+        if (isModern) {
+            menuRouteStack = listOf(overlayViewToMenuRoute(target))
+        } else {
+            overlayView = target
+        }
+    }
+
+    val showVideoFilters = {
+        if (metadataState.isVideoEffectsAvailable) {
+            videoFiltersInitialPreferences = playerPreferences
+            openOverlayPanel(OverlayView.VIDEO_FILTERS)
+        } else {
+            Toast.makeText(context, videoFiltersUnavailableMessage, Toast.LENGTH_SHORT).show()
+        }
+    }
+
+    fun dismissOverlay() {
+        if (overlayView == OverlayView.VIDEO_FILTERS || menuRouteStack.contains(MenuRoute.VideoFilters)) {
+            restoreVideoFiltersPreview()
+        }
+        overlayView = null
+        menuRouteStack = emptyList()
+    }
+
+    fun popMenuRoute() {
+        if (menuRouteStack.lastOrNull() == MenuRoute.VideoFilters) {
+            restoreVideoFiltersPreview()
+        }
+        if (menuRouteStack.size > 1) {
+            menuRouteStack = menuRouteStack.dropLast(1)
+        } else {
+            menuRouteStack = emptyList()
+        }
+    }
+
+    fun navigateToMenuRoute(target: MenuRoute) {
+        if (target == MenuRoute.VideoFilters) {
+            if (!metadataState.isVideoEffectsAvailable) {
+                Toast.makeText(context, videoFiltersUnavailableMessage, Toast.LENGTH_SHORT).show()
+                return
+            }
+            videoFiltersInitialPreferences = playerPreferences
+        }
+        menuRouteStack = menuRouteStack + target
+    }
+
+    var longPressOverlayAnimationStep by remember { mutableIntStateOf(0) }
+    val keyboardInteractionEnabledState = rememberUpdatedState(
+        overlayView == null && menuRouteStack.isEmpty() && !controlsVisibilityState.isControlsLocked
+    )
+    val seekIncrementState = rememberUpdatedState(playerPreferences.seekIncrement.seconds.inWholeMilliseconds)
+    val currentPlayerState = rememberUpdatedState(player)
+    val currentTapGestureState = rememberUpdatedState(tapGestureState)
+    val currentControlsVisibilityState = rememberUpdatedState(controlsVisibilityState)
+    val currentVolumeState = rememberUpdatedState(volumeState)
+
+    val keyboardController = remember {
+        PlayerKeyboardController(
+            onSeekBackward = {
+                currentPlayerState.value.seekByRequestedOffset(-seekIncrementState.value)
+                currentControlsVisibilityState.value.showControls()
+            },
+            onSeekForward = {
+                currentPlayerState.value.seekByRequestedOffset(seekIncrementState.value)
+                currentControlsVisibilityState.value.showControls()
+            },
+            onIncreaseVolume = {
+                currentVolumeState.value.increaseVolume(shouldShowVolumePanel = true)
+                currentControlsVisibilityState.value.showControls()
+            },
+            onDecreaseVolume = {
+                currentVolumeState.value.decreaseVolume(shouldShowVolumePanel = true)
+                currentControlsVisibilityState.value.showControls()
+            },
+            onTogglePlayPause = {
+                if (currentPlayerState.value.isPlaying) {
+                    currentPlayerState.value.pause()
+                } else {
+                    currentPlayerState.value.play()
+                }
+                currentControlsVisibilityState.value.showControls()
+            },
+            onStartTemporarySpeed = {
+                val didStart = currentTapGestureState.value.handleKeyboardLongPress()
+                if (didStart) {
+                    currentControlsVisibilityState.value.hideControls()
+                }
+                didStart
+            },
+            onStopTemporarySpeed = {
+                currentTapGestureState.value.handleOnLongPressRelease()
+            },
+        )
+    }
+
+    val keyboardEventHandler: (KeyEvent) -> Boolean = keyboardHandler@{ event ->
+        if (!keyboardInteractionEnabledState.value) return@keyboardHandler false
+        keyboardController.handleKeyEvent(event)
+    }
+
+    SideEffect {
+        onKeyboardEventHandlerChanged(keyboardEventHandler)
+    }
+
+    DisposableEffect(Unit) {
+        onDispose {
+            onKeyboardEventHandlerChanged { false }
+        }
+    }
+
+    val longPressOverlayUiState = resolveLongPressOverlayUiState(
+        isLongPressGestureInAction = tapGestureState.isLongPressGestureInAction,
+        isDebugLongPressOverlayVisible = playerPreferences.isDebugLongPressOverlayVisible,
+        longPressSpeed = tapGestureState.currentLongPressSpeed,
+        shouldShowOverlay = shouldShowOverlay,
+    )
+
+    LaunchedEffect(tapGestureState.isLongPressGestureInAction, tapGestureState.longPressSpeedChangeCount) {
+        if (!tapGestureState.isLongPressGestureInAction) {
+            shouldShowOverlay = false
+            return@LaunchedEffect
+        }
+        shouldShowOverlay = true
+        delay(3.seconds)
+        shouldShowOverlay = false
+    }
+
+    LaunchedEffect(longPressOverlayUiState != null) {
+        if (longPressOverlayUiState == null) {
+            longPressOverlayAnimationStep = 0
+            return@LaunchedEffect
+        }
+        while (true) {
+            longPressOverlayAnimationStep = 0
+            delay(120)
+            longPressOverlayAnimationStep = 1
+            delay(120)
+            longPressOverlayAnimationStep = 2
+            delay(120)
+            longPressOverlayAnimationStep = 3
+            delay(320)
+        }
+    }
+
+    CompositionLocalProvider(
+        LocalControlsVisibilityState provides controlsVisibilityState,
+        LocalPlayerIconStyle provides playerPreferences.playerIconStyle,
+    ) {
+        Box {
+            Box(
+                modifier = modifier
+                    .fillMaxSize()
+                    .background(Color.Black),
+            ) {
+                if (isAmbienceModeEnabled) {
+                    AmbienceBackground(artworkData = metadataState.artworkData)
+                }
+                
+                PlayerContentFrame(
+                    player = player,
+                    pictureInPictureState = pictureInPictureState,
+                    controlsVisibilityState = controlsVisibilityState,
+                    tapGestureState = tapGestureState,
+                    seekGestureState = seekGestureState,
+                    videoZoomAndContentScaleState = videoZoomAndContentScaleState,
+                    volumeAndBrightnessGestureState = volumeAndBrightnessGestureState,
+                    subtitleConfiguration = SubtitleConfiguration(
+                        shouldUseSystemCaptionStyle = playerPreferences.shouldUseSystemCaptionStyle,
+                        shouldShowBackground = playerPreferences.shouldShowSubtitleBackground,
+                        font = playerPreferences.subtitleFont,
+                        textSize = playerPreferences.subtitleTextSize,
+                        shouldUseBoldText = playerPreferences.shouldUseBoldSubtitleText,
+                        color = playerPreferences.subtitleColor,
+                        edgeStyle = playerPreferences.subtitleEdgeStyle,
+                        bottomPaddingFraction = playerPreferences.subtitleBottomPaddingFraction,
+                        shouldApplyEmbeddedStyles = playerPreferences.shouldApplyEmbeddedStyles,
+                        externalSubtitleFontSource = externalSubtitleFontSource,
+                    ),
+                    decoderPriority = playerPreferences.decoderPriority,
+                )
+
+                if (mediaPresentationState.isBuffering && mediaPresentationState.hasRenderedFirstFrame) {
+                    CircularProgressIndicator(
+                        modifier = Modifier
+                            .align(Alignment.Center)
+                            .size(72.dp),
+                    )
+                }
+                DoubleTapIndicator(tapGestureState = tapGestureState)
+
+                ExoPlayerControls(
+                    player = player,
+                    viewModel = viewModel,
+                    controlsVisibilityState = controlsVisibilityState,
+                    metadataState = metadataState,
+                    mediaPresentationState = mediaPresentationState,
+                    seekGestureState = seekGestureState,
+                    videoZoomAndContentScaleState = videoZoomAndContentScaleState,
+                    playerPreferences = playerPreferences,
+                    onBackClick = onBackClick,
+                    onOpenOverlay = ::openOverlayPanel,
+                    onScreenshotClick = onScreenshotClick,
+                    onPlayInBackgroundClick = onPlayInBackgroundClick,
+                    onRotateClick = { rotationState.rotate() },
+                    onPipClick = {
+                        if (!pictureInPictureState.hasPipPermission) {
+                            Toast.makeText(context, R.string.enable_pip_from_settings, Toast.LENGTH_SHORT).show()
+                            pictureInPictureState.openPictureInPictureSettings()
+                        } else {
+                            pictureInPictureState.enterPictureInPictureMode()
+                        }
+                    },
+                    onAspectRatioClick = {
+                        videoZoomAndContentScaleState.switchToNextVideoContentScale()
+                        controlsVisibilityState.showControls()
+                    },
+                    onVideoFiltersClick = showVideoFilters,
+                    onAmbienceModeClick = {
+                        viewModel.updateAmbienceMode(!isAmbienceModeEnabled)
+                        controlsVisibilityState.showControls()
+                    },
+                    isAmbienceModeEnabled = isAmbienceModeEnabled,
+                    modifier = Modifier.fillMaxSize()
+                )
+
+                if (longPressOverlayUiState != null) {
+                    val safeDrawingTopPadding = WindowInsets.safeDrawing.asPaddingValues().calculateTopPadding()
+                    val longPressOverlayTopPadding = maxOf(
+                        safeDrawingTopPadding,
+                        pictureInPictureState.videoViewRect?.top?.let { with(LocalDensity.current) { it.toDp() } } ?: 0.dp,
+                    ) + 16.dp
+                    LongPressSpeedOverlay(
+                        modifier = Modifier
+                            .align(Alignment.TopCenter)
+                            .padding(top = longPressOverlayTopPadding)
+                            .testTag("long_press_speed_overlay"),
+                        speedText = longPressOverlayUiState.speedText,
+                        animationStep = longPressOverlayAnimationStep,
+                    )
+                }
+
+                val systemBarsPadding = WindowInsets.systemBars.asPaddingValues()
+                Box(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .displayCutoutPadding()
+                        .padding(top = systemBarsPadding.calculateTopPadding(), bottom = systemBarsPadding.calculateBottomPadding())
+                        .padding(24.dp),
+                ) {
+                    AnimatedVisibility(
+                        modifier = Modifier.align(Alignment.CenterStart),
+                        visible = volumeAndBrightnessGestureState.activeGesture == VerticalGesture.VOLUME,
+                        enter = fadeIn(),
+                        exit = fadeOut(),
+                    ) {
+                        VerticalProgressView(
+                            value = volumeState.volumePercentage,
+                            maxValue = volumeState.maxVolumePercentage,
+                            icon = NextIcons.VolumeUp,
+                        )
+                    }
+
+                    AnimatedVisibility(
+                        modifier = Modifier.align(Alignment.CenterEnd),
+                        visible = volumeAndBrightnessGestureState.activeGesture == VerticalGesture.BRIGHTNESS,
+                        enter = fadeIn(),
+                        exit = fadeOut(),
+                    ) {
+                        VerticalProgressView(
+                            value = brightnessState.brightnessPercentage,
+                            icon = NextIcons.Brightness,
+                        )
+                    }
+                }
+            }
+
+            if (isModern || menuRouteStack.isNotEmpty()) {
+                val currentRoute = menuRouteStack.lastOrNull()
+                val canGoBack = menuRouteStack.size > 1
+                if (currentRoute != null) {
+                    Box(
+                        modifier = Modifier
+                            .matchParentSize()
+                            .noRippleClickable { dismissOverlay() },
+                    )
+                }
+                MenuOverlayView(
+                    externalRoute = currentRoute,
+                    title = titleForMenuRoute(currentRoute),
+                    canGoBack = canGoBack,
+                    onBack = {
+                        if (canGoBack) popMenuRoute() else dismissOverlay()
+                    },
+                ) { route ->
+                    when (route) {
+                        MenuRoute.Root -> MenuRootContent(
+                            isLockEnabled = controlsVisibilityState.isControlsLocked,
+                            isPipSupported = pictureInPictureState.isPipSupported,
+                            isTakingScreenshot = isTakingScreenshot,
+                            onNavigate = ::navigateToMenuRoute,
+                            onLockClick = {
+                                controlsVisibilityState.showControls()
+                                controlsVisibilityState.lockControls()
+                                dismissOverlay()
+                            },
+                            onAmbienceClick = {
+                                viewModel.updateAmbienceMode(!isAmbienceModeEnabled)
+                                dismissOverlay()
+                            },
+                            onPictureInPictureClick = {
+                                if (!pictureInPictureState.hasPipPermission) {
+                                    Toast.makeText(context, R.string.enable_pip_from_settings, Toast.LENGTH_SHORT).show()
+                                    pictureInPictureState.openPictureInPictureSettings()
+                                } else {
+                                    pictureInPictureState.enterPictureInPictureMode()
+                                }
+                                dismissOverlay()
+                            },
+                            onScreenshotClick = {
+                                onScreenshotClick()
+                                dismissOverlay()
+                            },
+                            onPlayInBackgroundClick = {
+                                onPlayInBackgroundClick()
+                                dismissOverlay()
+                            },
+                            onLoopClick = {
+                                player.repeatMode = when (player.repeatMode) {
+                                    Player.REPEAT_MODE_OFF -> Player.REPEAT_MODE_ONE
+                                    Player.REPEAT_MODE_ONE -> Player.REPEAT_MODE_ALL
+                                    else -> Player.REPEAT_MODE_OFF
+                                }
+                                dismissOverlay()
+                            },
+                            onShuffleClick = {
+                                player.shuffleModeEnabled = !player.shuffleModeEnabled
+                                dismissOverlay()
+                            },
+                            onStatsClick = {
+                                viewModel.updateStatisticsPage(if (playerPreferences.statisticsPage == 1) 0 else 1)
+                                dismissOverlay()
+                            }
+                        )
+                        MenuRoute.Audio -> AudioTrackSelectorContent(
+                            player = player,
+                            onDismiss = ::dismissOverlay,
+                        )
+                        MenuRoute.Subtitle -> SubtitleSelectorContent(
+                            player = player,
+                            onSelectSubtitleClick = onSelectSubtitleClick,
+                            onAddOnlineSubtitleClick = onAddOnlineSubtitleClick,
+                            preferences = playerPreferences,
+                            onPreferencesChange = viewModel::updateSubtitleStyle,
+                            onEvent = viewModel::onSubtitleOptionEvent,
+                            onDismiss = ::dismissOverlay,
+                        )
+                        MenuRoute.PlaybackSpeed -> PlaybackSpeedSelectorContent(player = player)
+                        MenuRoute.VideoContentScale -> VideoContentScaleSelectorContent(
+                            videoContentScale = videoZoomAndContentScaleState.videoContentScale,
+                            onVideoContentScaleChanged = {
+                                videoZoomAndContentScaleState.onVideoContentScaleChanged(it)
+                            },
+                            onShowVideoFilters = null,
+                            onDismiss = ::dismissOverlay,
+                        )
+                        MenuRoute.VideoFilters -> VideoFiltersPanel(
+                            preferences = playerPreferences,
+                            onDismissRequest = ::dismissOverlay,
+                            onPreviewPreferences = { previewPreferences ->
+                                (player as? androidx.media3.session.MediaController)?.previewVideoFilters(previewPreferences)
+                            },
+                            onConfirmPreferences = viewModel::updateVideoFilters,
+                        )
+                        MenuRoute.Playlist -> PlaylistContent(
+                            isVisible = true,
+                            player = player,
+                        )
+                        MenuRoute.SleepTimer -> SleepTimerSelectorContent(
+                            sleepTimerState = sleepTimerState,
+                            onDismiss = ::dismissOverlay,
+                        )
+                        MenuRoute.Decoder -> DecoderPrioritySelectorContent(
+                            currentDecoderPriority = playerPreferences.decoderPriority,
+                            onDecoderPriorityClick = {
+                                viewModel.updateDecoderPriority(it)
+                                dismissOverlay()
+                            },
+                            onDismiss = ::dismissOverlay,
+                        )
+                    }
+                }
+            } else {
+                OverlayShowView(
+                    player = player,
+                    overlayView = overlayView,
+                    videoContentScale = videoZoomAndContentScaleState.videoContentScale,
+                    playerPreferences = playerPreferences,
+                    sleepTimerState = sleepTimerState,
+                    onDismiss = ::dismissOverlay,
+                    onSelectSubtitleClick = onSelectSubtitleClick,
+                    onAddOnlineSubtitleClick = onAddOnlineSubtitleClick,
+                    onSubtitleOptionEvent = viewModel::onSubtitleOptionEvent,
+                    onSubtitleStyleChanged = viewModel::updateSubtitleStyle,
+                    onVideoContentScaleChanged = { videoZoomAndContentScaleState.onVideoContentScaleChanged(it) },
+                    onPreviewVideoFilters = { previewPreferences ->
+                        (player as? androidx.media3.session.MediaController)?.previewVideoFilters(previewPreferences)
+                    },
+                    onConfirmVideoFilters = viewModel::updateVideoFilters,
+                    onCloseVideoFilters = { overlayView = null },
+                    onShowVideoFilters = {
+                        overlayView = null
+                        showVideoFilters()
+                    },
+                    onDecoderPriorityChanged = {
+                        viewModel.updateDecoderPriority(it)
+                        dismissOverlay()
+                    },
+                )
+            }
+        }
+    }
+
+    errorState.error?.let { error ->
+        AlertDialog(
+            onDismissRequest = { },
+            title = { Text(text = stringResource(R.string.error_playing_video)) },
+            text = { Text(text = error.message ?: stringResource(R.string.unknown_error)) },
+            confirmButton = {
+                if (player.hasNextMediaItem()) {
+                    TextButton(
+                        onClick = {
+                            errorState.dismiss()
+                            player.seekToNext()
+                            player.play()
+                        },
+                    ) { Text(text = stringResource(R.string.play_next_video)) }
+                }
+            },
+            dismissButton = {
+                TextButton(
+                    onClick = {
+                        errorState.dismiss()
+                        onBackClick()
+                    },
+                ) { Text(text = stringResource(R.string.exo_exit)) }
+            },
+        )
+    }
+
+    BackHandler {
+        when {
+            menuRouteStack.size > 1 -> popMenuRoute()
+            menuRouteStack.isNotEmpty() -> dismissOverlay()
+            overlayView != null -> dismissOverlay()
+            else -> onBackClick()
+        }
+    }
+}
+
+@Composable
+private fun titleForMenuRoute(route: MenuRoute?): String = when (route) {
+    null, MenuRoute.Root -> stringResource(R.string.menu)
+    MenuRoute.Audio -> stringResource(R.string.select_audio_track)
+    MenuRoute.Subtitle -> stringResource(R.string.select_subtitle_track)
+    MenuRoute.PlaybackSpeed -> stringResource(R.string.select_playback_speed)
+    MenuRoute.VideoContentScale -> stringResource(R.string.video_zoom)
+    MenuRoute.VideoFilters -> stringResource(R.string.video_filters)
+    MenuRoute.Playlist -> stringResource(R.string.now_playing)
+    MenuRoute.SleepTimer -> stringResource(R.string.exo_sleep_timer)
+    MenuRoute.Decoder -> stringResource(R.string.decoder_priority)
+}
+
+@Composable
+private fun AmbienceBackground(
+    artworkData: ByteArray?,
+    modifier: Modifier = Modifier,
+) {
+    artworkData ?: return
+    val imageBitmap = remember(artworkData) {
+        runCatching {
+            BitmapFactory.decodeByteArray(artworkData, 0, artworkData.size).asImageBitmap()
+        }.getOrNull()
+    } ?: return
+
+    Image(
+        bitmap = imageBitmap,
+        contentDescription = null,
+        contentScale = ContentScale.Crop,
+        modifier = modifier.fillMaxSize().blur(48.dp),
+        alpha = 0.9f,
+    )
+    Box(
+        modifier = modifier.fillMaxSize().background(Color.Black.copy(alpha = 0.42f)),
+    )
+}
+
+@Composable
+private fun LongPressSpeedOverlay(
+    speedText: String,
+    animationStep: Int,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = modifier
+            .background(color = Color.Black.copy(alpha = 0.08f), shape = RoundedCornerShape(8.dp))
+            .padding(horizontal = 10.dp, vertical = 6.dp),
+        horizontalArrangement = Arrangement.spacedBy(3.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        LongPressSpeedIndicator(animationStep = animationStep)
+        Text(
+            text = speedText,
+            modifier = Modifier.testTag("long_press_speed_text"),
+            style = MaterialTheme.typography.titleSmall.copy(
+                fontWeight = FontWeight.Bold,
+                shadow = Shadow(color = Color.Black.copy(alpha = 0.10f), offset = Offset(0f, 1f), blurRadius = 2f),
+            ),
+            color = Color.White,
+        )
+    }
+}
+
+@Composable
+private fun LongPressSpeedIndicator(
+    animationStep: Int,
+    modifier: Modifier = Modifier,
+) {
+    val alpha1 by animateFloatAsState(targetValue = if (animationStep >= 1) 1f else 0f, label = "lp_1")
+    val alpha2 by animateFloatAsState(targetValue = if (animationStep >= 2) 1f else 0f, label = "lp_2")
+    val alpha3 by animateFloatAsState(targetValue = if (animationStep >= 3) 1f else 0f, label = "lp_3")
+
+    Row(modifier = modifier, horizontalArrangement = Arrangement.spacedBy((-1).dp), verticalAlignment = Alignment.CenterVertically) {
+        LongPressSpeedArrow(alpha = alpha1)
+        LongPressSpeedArrow(alpha = alpha2)
+        LongPressSpeedArrow(alpha = alpha3)
+    }
+}
+
+@Composable
+private fun LongPressSpeedArrow(alpha: Float) {
+    Icon(
+        imageVector = NextIcons.Play,
+        contentDescription = null,
+        modifier = Modifier.size(11.dp),
+        tint = Color.White.copy(alpha = alpha),
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/PlayerContentFrame.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/PlayerContentFrame.kt
new file mode 100644
index 000000000..9b1e1d47f
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/PlayerContentFrame.kt
@@ -0,0 +1,188 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player
+
+import android.graphics.Rect
+import androidx.annotation.OptIn
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.requiredSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.boundsInWindow
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.platform.LocalDensity
+import androidx.media3.common.C
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.compose.PlayerSurface
+import androidx.media3.ui.compose.SURFACE_TYPE_SURFACE_VIEW
+import androidx.media3.ui.compose.state.rememberPresentationState
+import kotlin.math.max
+import kotlin.math.min
+import kotlinx.coroutines.delay
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+import app.gyrolet.mpvrx.exoplayer.core.model.VideoContentScale
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.hasRenderedFirstFrame
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.ControlsVisibilityState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.PictureInPictureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SeekGestureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.TapGestureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.VideoZoomAndContentScaleState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.VolumeAndBrightnessGestureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberTracksState
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.PlayerGestures
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.ShutterView
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.SubtitleConfiguration
+import app.gyrolet.mpvrx.exoplayer.feature.player.ui.SubtitleView
+
+@OptIn(UnstableApi::class)
+@Composable
+fun PlayerContentFrame(
+    modifier: Modifier = Modifier,
+    player: Player,
+    pictureInPictureState: PictureInPictureState,
+    controlsVisibilityState: ControlsVisibilityState,
+    tapGestureState: TapGestureState,
+    seekGestureState: SeekGestureState,
+    videoZoomAndContentScaleState: VideoZoomAndContentScaleState,
+    volumeAndBrightnessGestureState: VolumeAndBrightnessGestureState,
+    subtitleConfiguration: SubtitleConfiguration,
+    decoderPriority: DecoderPriority,
+    isGesturesEnabled: Boolean = true,
+) {
+    // decoder 切换重建 SurfaceView，重新绑定视频输出
+    var surfaceRefreshKey by remember { mutableIntStateOf(0) }
+    var previousDecoderPriority by remember { mutableStateOf(decoderPriority) }
+    LaunchedEffect(decoderPriority) {
+        if (previousDecoderPriority == decoderPriority) return@LaunchedEffect
+        previousDecoderPriority = decoderPriority
+        surfaceRefreshKey++
+        delay(120)
+        surfaceRefreshKey++
+    }
+
+    val presentationState = rememberPresentationState(player)
+    val density = LocalDensity.current
+    val textTracksState = rememberTracksState(player = player, trackType = C.TRACK_TYPE_TEXT)
+    val isAssSubtitleSelected = textTracksState.tracks.any { track ->
+        track.isSelected &&
+            (0 until track.mediaTrackGroup.length).any { index ->
+                val format = track.mediaTrackGroup.getFormat(index)
+                format.sampleMimeType == MimeTypes.TEXT_SSA || format.codecs == MimeTypes.TEXT_SSA
+            }
+    }
+    var lastLoggedSurfaceLayout by remember { mutableStateOf("") }
+
+    // Media3 1.10.1 的 videoSizeDp 名带 Dp 但实际存视频原始 px；ASS wrapper 不触发 onVideoSizeChanged，回退 metadata
+    val videoSizePx = presentationState.videoSizeDp ?: run {
+        val w = videoZoomAndContentScaleState.metadataVideoWidth.toFloat()
+        val h = videoZoomAndContentScaleState.metadataVideoHeight.toFloat()
+        if (w <= 0f || h <= 0f) return@run null
+        val rotation = videoZoomAndContentScaleState.metadataVideoRotation
+        if (rotation == 90 || rotation == 270) Size(h, w) else Size(w, h)
+    }
+
+    key(surfaceRefreshKey) {
+        BoxWithConstraints(
+            modifier = modifier.fillMaxSize(),
+            contentAlignment = Alignment.Center,
+        ) {
+            val containerWidth = constraints.maxWidth.toFloat().coerceAtLeast(1f)
+            val containerHeight = constraints.maxHeight.toFloat().coerceAtLeast(1f)
+            val videoWidth = videoSizePx?.width ?: containerWidth
+            val videoHeight = (videoSizePx?.height ?: containerHeight).coerceAtLeast(1f)
+            val fillX = containerWidth / videoWidth
+            val fillY = containerHeight / videoHeight
+
+            // SurfaceView 锁视频原始 px，避开 holder resize 异步竞态；graphicsLayer 缩放使 HUNDRED_PERCENT 1:1 无插值
+            val (baseScaleX, baseScaleY) = when (videoZoomAndContentScaleState.videoContentScale) {
+                VideoContentScale.STRETCH -> fillX to fillY
+                VideoContentScale.BEST_FIT -> min(fillX, fillY).let { it to it }
+                VideoContentScale.CROP -> max(fillX, fillY).let { it to it }
+                VideoContentScale.HUNDRED_PERCENT -> 1f to 1f
+            }
+            val surfaceWidthDp = with(density) { videoWidth.toDp() }
+            val surfaceHeightDp = with(density) { videoHeight.toDp() }
+
+            PlayerSurface(
+                player = player,
+                surfaceType = SURFACE_TYPE_SURFACE_VIEW,
+                modifier = Modifier
+                    .requiredSize(surfaceWidthDp, surfaceHeightDp)
+                    .graphicsLayer {
+                        scaleX = baseScaleX * videoZoomAndContentScaleState.zoom
+                        scaleY = baseScaleY * videoZoomAndContentScaleState.zoom
+                        translationX = videoZoomAndContentScaleState.offset.x
+                        translationY = videoZoomAndContentScaleState.offset.y
+                    }
+                    .onGloballyPositioned {
+                        val bounds = it.boundsInWindow()
+                        val rect = Rect(
+                            bounds.left.toInt(),
+                            bounds.top.toInt(),
+                            bounds.right.toInt(),
+                            bounds.bottom.toInt(),
+                        )
+                        val key = "${rect.width()}x${rect.height()}@${rect.left},${rect.top}:${videoZoomAndContentScaleState.videoContentScale}:${videoSizePx?.width}x${videoSizePx?.height}:$surfaceRefreshKey"
+                        if (key != lastLoggedSurfaceLayout) {
+                            lastLoggedSurfaceLayout = key
+                            Logger.info(
+                                TAG,
+                                "Player surface layout size=${rect.width()}x${rect.height()} left=${rect.left} top=${rect.top} contentScale=${videoZoomAndContentScaleState.videoContentScale} videoPx=${videoSizePx?.width}x${videoSizePx?.height} coverSurface=${presentationState.coverSurface} refresh=$surfaceRefreshKey",
+                            )
+                        }
+                        pictureInPictureState.updateVideoViewRect(rect)
+                    },
+            )
+
+            if (!presentationState.coverSurface) {
+                val subtitleModifier = if (isAssSubtitleSelected) {
+                    val subtitleScale = min(fillX, fillY)
+                    Modifier
+                        .requiredSize(surfaceWidthDp, surfaceHeightDp)
+                        .graphicsLayer {
+                            scaleX = subtitleScale
+                            scaleY = subtitleScale
+                        }
+                } else {
+                    val subtitleWidthDp = with(density) { min(containerWidth, videoWidth * baseScaleX).toDp() }
+                    val subtitleHeightDp = with(density) { min(containerHeight, videoHeight * baseScaleY).toDp() }
+                    Modifier.requiredSize(subtitleWidthDp, subtitleHeightDp)
+                }
+                SubtitleView(
+                    modifier = subtitleModifier,
+                    player = player,
+                    isInPictureInPictureMode = pictureInPictureState.isInPictureInPictureMode,
+                    configuration = subtitleConfiguration,
+                )
+            }
+        }
+    }
+
+    PlayerGestures(
+        controlsVisibilityState = controlsVisibilityState,
+        tapGestureState = tapGestureState,
+        pictureInPictureState = pictureInPictureState,
+        seekGestureState = seekGestureState,
+        videoZoomAndContentScaleState = videoZoomAndContentScaleState,
+        volumeAndBrightnessGestureState = volumeAndBrightnessGestureState,
+        isEnabled = isGesturesEnabled,
+    )
+
+    if (presentationState.coverSurface) {
+        ShutterView()
+    }
+}
+
+private const val TAG = "PlayerContentFrame"
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/PlayerControlsDragDrop.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/PlayerControlsDragDrop.kt
new file mode 100644
index 000000000..abc7a6cf7
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/PlayerControlsDragDrop.kt
@@ -0,0 +1,193 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.VectorConverter
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.offset
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.composed
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.boundsInWindow
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.unit.IntOffset
+import kotlin.math.abs
+import kotlin.math.roundToInt
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControl
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControlZone
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControlsLayout
+
+internal fun PlayerControlsLayout.dropDraggedControl(
+    control: PlayerControl,
+    dragOffset: Offset,
+    itemBounds: Map<PlayerControl, Rect>,
+    zoneBounds: Map<PlayerControlZone, Rect>,
+): PlayerControlsLayout {
+    val sourceBounds = itemBounds[control] ?: return this
+    return dropControl(
+        control = control,
+        dropPosition = sourceBounds.center + dragOffset,
+        itemBounds = itemBounds,
+        zoneBounds = zoneBounds,
+    )
+}
+
+internal fun PlayerControlsLayout.previewReorder(
+    control: PlayerControl,
+    dropPosition: Offset,
+    itemBounds: Map<PlayerControl, Rect>,
+): PlayerControlsLayout {
+    val sourceZone = entries.firstOrNull { it.control == control }?.zone ?: return this
+    val controlsInZone = controlsIn(sourceZone).filterNot { it == control }
+    val insertionIndex = controlsInZone.indexOfFirst { candidate ->
+        val bounds = itemBounds[candidate] ?: return@indexOfFirst false
+        dropPosition.x < bounds.center.x
+    }.takeIf { it >= 0 } ?: controlsInZone.size
+
+    return move(
+        control = control,
+        toZone = sourceZone,
+        toIndex = insertionIndex,
+    )
+}
+
+internal fun PlayerControlsLayout.dropControl(
+    control: PlayerControl,
+    dropPosition: Offset,
+    itemBounds: Map<PlayerControl, Rect>,
+    zoneBounds: Map<PlayerControlZone, Rect>,
+): PlayerControlsLayout {
+    val targetZone = resolveDropZone(
+        dropPosition = dropPosition,
+        zoneBounds = zoneBounds,
+    ) ?: return this
+
+    val controlsInZone = controlsIn(targetZone).filterNot { it == control }
+    val insertionIndex = controlsInZone.indexOfFirst { candidate ->
+        val bounds = itemBounds[candidate] ?: return@indexOfFirst false
+        dropPosition.x < bounds.center.x
+    }.takeIf { it >= 0 } ?: controlsInZone.size
+
+    return move(
+        control = control,
+        toZone = targetZone,
+        toIndex = insertionIndex,
+    )
+}
+
+@Composable
+internal fun AnimatedPlayerControlPlacement(
+    control: PlayerControl,
+    itemBounds: MutableMap<PlayerControl, Rect>,
+    isTracking: Boolean,
+    modifier: Modifier = Modifier,
+    content: @Composable () -> Unit,
+) {
+    if (!isTracking) {
+        Box(modifier = modifier) {
+            content()
+        }
+        return
+    }
+
+    val scope = rememberCoroutineScope()
+    val animatedOffset = remember(control) { Animatable(Offset.Zero, Offset.VectorConverter) }
+
+    Box(
+        modifier = modifier.onGloballyPositioned { coordinates ->
+            val bounds = coordinates.boundsInWindow()
+            val previousBounds = itemBounds.put(control, bounds)
+            val delta = previousBounds?.topLeft?.minus(bounds.topLeft) ?: Offset.Zero
+            val distanceSquared = (delta.x * delta.x) + (delta.y * delta.y)
+            if (distanceSquared < 1f) return@onGloballyPositioned
+
+            scope.launch {
+                animatedOffset.stop()
+                animatedOffset.snapTo(delta)
+                animatedOffset.animateTo(
+                    targetValue = Offset.Zero,
+                    animationSpec = tween(durationMillis = 180),
+                )
+            }
+        },
+    ) {
+        Box(
+            modifier = Modifier.offset {
+                IntOffset(
+                    x = animatedOffset.value.x.roundToInt(),
+                    y = animatedOffset.value.y.roundToInt(),
+                )
+            },
+        ) {
+            content()
+        }
+    }
+}
+
+internal fun Modifier.playerControlZoneTarget(
+    zone: PlayerControlZone,
+    zoneBounds: MutableMap<PlayerControlZone, Rect>,
+): Modifier = onGloballyPositioned {
+    zoneBounds[zone] = it.boundsInWindow()
+}
+
+internal fun Modifier.playerControlDragSource(
+    control: PlayerControl,
+    enabled: Boolean,
+    onDropDragged: (PlayerControl, Offset) -> Unit,
+    onDragStarted: (PlayerControl) -> Unit = {},
+    onDragMoved: (PlayerControl, Offset) -> Unit = { _, _ -> },
+    onDragCancelled: (PlayerControl) -> Unit = {},
+): Modifier = if (!enabled) {
+    this
+} else {
+    composed {
+        val currentOnDropDragged by rememberUpdatedState(onDropDragged)
+        val currentOnDragStarted by rememberUpdatedState(onDragStarted)
+        val currentOnDragMoved by rememberUpdatedState(onDragMoved)
+        val currentOnDragCancelled by rememberUpdatedState(onDragCancelled)
+
+        pointerInput(control, enabled) {
+            var totalDrag = Offset.Zero
+            detectDragGesturesAfterLongPress(
+                onDragStart = {
+                    totalDrag = Offset.Zero
+                    currentOnDragStarted(control)
+                },
+                onDrag = { change, dragAmount ->
+                    change.consume()
+                    totalDrag += dragAmount
+                    currentOnDragMoved(control, totalDrag)
+                },
+                onDragEnd = {
+                    currentOnDropDragged(control, totalDrag)
+                },
+                onDragCancel = {
+                    currentOnDragCancelled(control)
+                },
+            )
+        }
+    }
+}
+
+internal fun resolveDropZone(
+    dropPosition: Offset,
+    zoneBounds: Map<PlayerControlZone, Rect>,
+): PlayerControlZone? {
+    zoneBounds.entries.firstOrNull { (_, bounds) -> bounds.contains(dropPosition) }?.let { entry ->
+        return entry.key
+    }
+
+    return zoneBounds.minByOrNull { (_, bounds) ->
+        abs(dropPosition.y - bounds.center.y)
+    }?.key
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/PlayerViewModel.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/PlayerViewModel.kt
new file mode 100644
index 000000000..adafdb991
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/PlayerViewModel.kt
@@ -0,0 +1,309 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player
+
+import android.net.Uri
+import androidx.compose.runtime.Stable
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import androidx.media3.common.MediaItem
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.round
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.ExternalSubtitleFontSource
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.MediaRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.SubtitleFontRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.buildRemotePlaybackStateKey
+import app.gyrolet.mpvrx.exoplayer.core.domain.GetSortedPlaylistUseCase
+import app.gyrolet.mpvrx.exoplayer.core.model.ApplicationPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+import app.gyrolet.mpvrx.exoplayer.core.model.LastPlayerScreenOrientation
+import app.gyrolet.mpvrx.exoplayer.core.model.LoopMode
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControl
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControlsLayout
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.Video
+import app.gyrolet.mpvrx.exoplayer.core.model.VideoContentScale
+import app.gyrolet.mpvrx.exoplayer.core.model.withSubtitleStyleFrom
+import app.gyrolet.mpvrx.exoplayer.core.model.withVideoFiltersFrom
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.remoteFilePath
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.remoteProtocol
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.remoteServerId
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SubtitleOptionsEvent
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.VideoZoomEvent
+
+private fun Float.normalizeVideoFilter(
+    minimumValue: Float,
+    maximumValue: Float,
+    decimals: Int = 2,
+): Float = coerceIn(minimumValue, maximumValue).round(decimals)
+
+internal fun normalizeVideoSharpening(value: Float): Float = value
+    .normalizeVideoFilter(PlayerPreferences.DEFAULT_VIDEO_SHARPENING, PlayerPreferences.MAX_VIDEO_SHARPENING)
+
+class PlayerViewModel(
+    private val mediaRepository: MediaRepository,
+    private val preferencesRepository: PreferencesRepository,
+    private val subtitleFontRepository: SubtitleFontRepository,
+    private val getSortedPlaylistUseCase: GetSortedPlaylistUseCase,
+) : ViewModel() {
+
+    private companion object {
+        const val TAG = "PlayerViewModel"
+    }
+
+    var shouldPlayWhenReady: Boolean = true
+
+    private val internalUiState = MutableStateFlow(
+        PlayerUiState(
+            playerPreferences = preferencesRepository.playerPreferences.value,
+            applicationPreferences = preferencesRepository.applicationPreferences.value,
+            shouldPreventScreenshots = preferencesRepository.applicationPreferences.value.shouldPreventScreenshots,
+            shouldHideInRecents = preferencesRepository.applicationPreferences.value.shouldHideInRecents,
+        ),
+    )
+    val uiState = internalUiState.asStateFlow()
+
+    init {
+        android.util.Log.d("PlayerViewModel", "init starting")
+        viewModelScope.launch {
+            try {
+                preferencesRepository.playerPreferences.collect { prefs ->
+                    internalUiState.update { it.copy(playerPreferences = prefs) }
+                }
+            } catch (e: Exception) {
+                android.util.Log.e("PlayerViewModel", "Failed to collect player preferences", e)
+            }
+        }
+        viewModelScope.launch {
+            try {
+                preferencesRepository.applicationPreferences.collect { prefs ->
+                    internalUiState.update {
+                        it.copy(
+                            applicationPreferences = prefs,
+                            shouldPreventScreenshots = prefs.shouldPreventScreenshots,
+                            shouldHideInRecents = prefs.shouldHideInRecents,
+                        )
+                    }
+                }
+            } catch (e: Exception) {
+                android.util.Log.e("PlayerViewModel", "Failed to collect app preferences", e)
+            }
+        }
+        viewModelScope.launch {
+            try {
+                subtitleFontRepository.source.collect { source ->
+                    internalUiState.update { it.copy(externalSubtitleFontSource = source) }
+                }
+            } catch (e: Exception) {
+                android.util.Log.e("PlayerViewModel", "Failed to collect font source", e)
+            }
+        }
+        android.util.Log.d("PlayerViewModel", "init finished")
+    }
+
+    suspend fun getPlaylistFromUri(uri: Uri): List<Video> = getSortedPlaylistUseCase.invoke(uri)
+
+    suspend fun getVideoByUri(uri: String): Video? = mediaRepository.getVideoByUri(uri)
+
+    fun updateVideoZoom(uri: String, zoom: Float) {
+        viewModelScope.launch {
+            mediaRepository.updateMediumZoom(uri, zoom)
+        }
+    }
+
+    fun updatePlayerBrightness(value: Float) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences { it.copy(playerBrightness = value) }
+        }
+    }
+
+    fun updatePlayerVolume(percentage: Int) {
+        viewModelScope.launch {
+            val clampedPercentage = percentage.coerceIn(
+                minimumValue = 0,
+                maximumValue = PlayerPreferences.MAX_PLAYER_VOLUME_PERCENTAGE,
+            )
+            Logger.debug(TAG, "Remember player volume: percentage=$clampedPercentage")
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(playerVolumePercentage = clampedPercentage)
+            }
+        }
+    }
+
+    fun updateLastPlayerScreenOrientation(value: LastPlayerScreenOrientation) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences { preferences ->
+                if (!preferences.shouldRememberPlayerScreenOrientation) return@updatePlayerPreferences preferences
+                preferences.copy(lastPlayerScreenOrientation = value)
+            }
+        }
+    }
+
+    fun updateVideoContentScale(contentScale: VideoContentScale) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences { it.copy(playerVideoZoom = contentScale) }
+        }
+    }
+
+    fun updateDecoderPriority(decoderPriority: DecoderPriority) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(decoderPriority = decoderPriority)
+            }
+        }
+    }
+
+    fun updateStatisticsPage(page: Int) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(statisticsPage = page)
+            }
+        }
+    }
+
+    fun updateAmbienceMode(isEnabled: Boolean) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(isAmbienceModeEnabled = isEnabled)
+            }
+        }
+    }
+
+    fun updateVideoBrightness(value: Float) {
+        val normalizedValue = value.normalizeVideoFilter(PlayerPreferences.MIN_VIDEO_BRIGHTNESS, PlayerPreferences.MAX_VIDEO_BRIGHTNESS)
+        updateVideoFilter("brightness=$normalizedValue") { it.copy(videoBrightness = normalizedValue) }
+    }
+
+    fun updateVideoFilters(preferences: PlayerPreferences) {
+        val normalizedPreferences = preferences.normalizedVideoFilters()
+        updateVideoFilter("confirmed=$normalizedPreferences") {
+            it.withVideoFiltersFrom(normalizedPreferences)
+        }
+    }
+
+    fun updateVideoContrast(value: Float) {
+        val normalizedValue = value.normalizeVideoFilter(PlayerPreferences.MIN_VIDEO_CONTRAST, PlayerPreferences.MAX_VIDEO_CONTRAST)
+        updateVideoFilter("contrast=$normalizedValue") { it.copy(videoContrast = normalizedValue) }
+    }
+
+    fun updateVideoSaturation(value: Float) {
+        val normalizedValue = value.normalizeVideoFilter(PlayerPreferences.MIN_VIDEO_SATURATION, PlayerPreferences.MAX_VIDEO_SATURATION, decimals = 0)
+        updateVideoFilter("saturation=$normalizedValue") { it.copy(videoSaturation = normalizedValue) }
+    }
+
+    fun updateVideoHue(value: Float) {
+        val normalizedValue = value.normalizeVideoFilter(PlayerPreferences.MIN_VIDEO_HUE, PlayerPreferences.MAX_VIDEO_HUE, decimals = 0)
+        updateVideoFilter("hue=$normalizedValue") { it.copy(videoHue = normalizedValue) }
+    }
+
+    fun updateVideoGamma(value: Float) {
+        val normalizedValue = value.normalizeVideoFilter(PlayerPreferences.MIN_VIDEO_GAMMA, PlayerPreferences.MAX_VIDEO_GAMMA)
+        updateVideoFilter("gamma=$normalizedValue") { it.copy(videoGamma = normalizedValue) }
+    }
+
+    fun updateVideoSharpening(value: Float) {
+        val normalizedValue = normalizeVideoSharpening(value)
+        updateVideoFilter("sharpening=$normalizedValue") { it.copy(videoSharpening = normalizedValue) }
+    }
+
+    private fun PlayerPreferences.normalizedVideoFilters(): PlayerPreferences = copy(
+        videoBrightness = videoBrightness.normalizeVideoFilter(PlayerPreferences.MIN_VIDEO_BRIGHTNESS, PlayerPreferences.MAX_VIDEO_BRIGHTNESS),
+        videoContrast = videoContrast.normalizeVideoFilter(PlayerPreferences.MIN_VIDEO_CONTRAST, PlayerPreferences.MAX_VIDEO_CONTRAST),
+        videoSaturation = videoSaturation.normalizeVideoFilter(PlayerPreferences.MIN_VIDEO_SATURATION, PlayerPreferences.MAX_VIDEO_SATURATION, decimals = 0),
+        videoHue = videoHue.normalizeVideoFilter(PlayerPreferences.MIN_VIDEO_HUE, PlayerPreferences.MAX_VIDEO_HUE, decimals = 0),
+        videoGamma = videoGamma.normalizeVideoFilter(PlayerPreferences.MIN_VIDEO_GAMMA, PlayerPreferences.MAX_VIDEO_GAMMA),
+        videoSharpening = normalizeVideoSharpening(videoSharpening),
+    )
+
+    private fun updateVideoFilter(
+        debugValue: String,
+        transform: (PlayerPreferences) -> PlayerPreferences,
+    ) {
+        Logger.debug(TAG, "Update video filter from player: $debugValue")
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences(transform)
+        }
+    }
+
+    fun setLoopMode(loopMode: LoopMode) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences { it.copy(loopMode = loopMode) }
+        }
+    }
+
+    fun updateSubtitleStyle(preferences: PlayerPreferences) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.withSubtitleStyleFrom(preferences)
+            }
+        }
+    }
+
+    fun updatePlayerControlsCustomization(
+        hiddenControls: Set<PlayerControl>,
+        layout: PlayerControlsLayout,
+    ) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(
+                    hiddenPlayerControls = hiddenControls,
+                    playerControlsLayout = layout,
+                )
+            }
+        }
+    }
+
+    fun onVideoZoomEvent(event: VideoZoomEvent) {
+        when (event) {
+            is VideoZoomEvent.ContentScaleChanged -> {
+                updateVideoContentScale(event.contentScale)
+            }
+            is VideoZoomEvent.ZoomChanged -> {
+                updateVideoZoom(event.mediaItem.resolvePlaybackStateUri(), event.zoom)
+            }
+        }
+    }
+
+    fun onSubtitleOptionEvent(event: SubtitleOptionsEvent) {
+        when (event) {
+            is SubtitleOptionsEvent.DelayChanged -> {
+                updateSubtitleDelay(event.mediaItem.resolvePlaybackStateUri(), event.delay)
+            }
+            is SubtitleOptionsEvent.SpeedChanged -> {
+                updateSubtitleSpeed(event.mediaItem.resolvePlaybackStateUri(), event.speed)
+            }
+        }
+    }
+
+    private fun updateSubtitleDelay(uri: String, delay: Long) {
+        viewModelScope.launch {
+            mediaRepository.updateSubtitleDelay(uri, delay)
+        }
+    }
+
+    private fun updateSubtitleSpeed(uri: String, speed: Float) {
+        viewModelScope.launch {
+            mediaRepository.updateSubtitleSpeed(uri, speed)
+        }
+    }
+
+    private fun MediaItem.resolvePlaybackStateUri(): String = buildRemotePlaybackStateKey(
+        remoteProtocol = mediaMetadata.remoteProtocol,
+        remoteServerId = mediaMetadata.remoteServerId,
+        remoteFilePath = mediaMetadata.remoteFilePath,
+    ) ?: mediaId
+}
+
+@Stable
+data class PlayerUiState(
+    val playerPreferences: PlayerPreferences? = null,
+    val applicationPreferences: ApplicationPreferences = ApplicationPreferences(),
+    val shouldPreventScreenshots: Boolean = false,
+    val shouldHideInRecents: Boolean = false,
+    val externalSubtitleFontSource: ExternalSubtitleFontSource? = null,
+)
+
+sealed interface PlayerEvent
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/NextButton.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/NextButton.kt
new file mode 100644
index 000000000..0c997677e
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/NextButton.kt
@@ -0,0 +1,53 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.buttons
+
+import androidx.annotation.OptIn
+import androidx.compose.foundation.layout.size
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.compose.state.rememberNextButtonState
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.feature.player.LocalControlsVisibilityState
+
+@OptIn(UnstableApi::class)
+@Composable
+internal fun NextButton(
+    player: Player,
+    modifier: Modifier = Modifier,
+    isSelected: Boolean = false,
+    label: String? = null,
+    isInteractive: Boolean = true,
+    onClick: (() -> Unit)? = null,
+) {
+    val state = rememberNextButtonState(player)
+    val controlsVisibilityState = LocalControlsVisibilityState.current
+
+    PlayerButton(
+        modifier = modifier,
+        buttonSize = 48.dp,
+        isEnabled = state.isEnabled,
+        isSelected = isSelected,
+        label = label,
+        isInteractive = isInteractive,
+        onClick = {
+            if (onClick != null) {
+                onClick()
+            } else {
+                state.onClick()
+                controlsVisibilityState?.showControls()
+            }
+        },
+    ) {
+        Icon(
+            imageVector = NextIcons.SkipNext,
+            contentDescription = stringResource(R.string.player_controls_next),
+            modifier = Modifier.size(28.dp),
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/PlayPauseButton.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/PlayPauseButton.kt
new file mode 100644
index 000000000..eea555e4b
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/PlayPauseButton.kt
@@ -0,0 +1,52 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.buttons
+
+import androidx.annotation.OptIn
+import androidx.compose.foundation.layout.size
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.compose.state.rememberPlayPauseButtonState
+import app.gyrolet.mpvrx.R
+
+@OptIn(UnstableApi::class)
+@Composable
+fun PlayPauseButton(
+    player: Player,
+    modifier: Modifier = Modifier,
+    isSelected: Boolean = false,
+    label: String? = null,
+    isInteractive: Boolean = true,
+    onClick: (() -> Unit)? = null,
+) {
+    val state = rememberPlayPauseButtonState(player)
+    val icon = when (state.showPlay) {
+        true -> NextIcons.Play
+        false -> NextIcons.Pause
+    }
+    val contentDescription = when (state.showPlay) {
+        true -> stringResource(R.string.play_pause)
+        false -> stringResource(R.string.play_pause)
+    }
+
+    PlayerButton(
+        modifier = modifier,
+        buttonSize = 64.dp,
+        isEnabled = state.isEnabled,
+        isSelected = isSelected,
+        label = label,
+        isInteractive = isInteractive,
+        onClick = onClick ?: state::onClick,
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = contentDescription,
+            modifier = Modifier.size(48.dp),
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/PlayerButton.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/PlayerButton.kt
new file mode 100644
index 000000000..c60792b75
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/PlayerButton.kt
@@ -0,0 +1,278 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.buttons
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.PressInteraction
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.ripple.RippleAlpha
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.IconButtonDefaults
+import androidx.compose.material3.LocalContentColor
+import androidx.compose.material3.LocalRippleConfiguration
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RippleConfiguration
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.PathEffect
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.platform.LocalViewConfiguration
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.collectLatest
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerIconStyle
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.feature.player.LocalPlayerIconStyle
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun PlayerButton(
+    modifier: Modifier = Modifier,
+    buttonSize: Dp = 40.dp,
+    isEnabled: Boolean = true,
+    isSelected: Boolean = false,
+    label: String? = null,
+    shouldShowSelectionBadge: Boolean = isSelected,
+    shouldDimWhenUnselected: Boolean = false,
+    shouldShowCustomizeFrame: Boolean = false,
+    isInteractive: Boolean = true,
+    isOutlineOnly: Boolean = false,
+    onClick: () -> Unit,
+    onLongClick: (() -> Unit)? = null,
+    content: @Composable () -> Unit,
+) {
+    val interactionSource = remember { MutableInteractionSource() }
+    val viewConfiguration = LocalViewConfiguration.current
+    val hapticFeedback = LocalHapticFeedback.current
+    val isCustomizingButton = label != null
+
+    val currentOnClick by rememberUpdatedState(onClick)
+    val currentOnLongClick by rememberUpdatedState(onLongClick)
+    val currentIsInteractive by rememberUpdatedState(isInteractive)
+
+    LaunchedEffect(interactionSource) {
+        var isLongPressClicked = false
+        interactionSource.interactions.collectLatest { interaction ->
+            if (!currentIsInteractive) return@collectLatest
+            when (interaction) {
+                is PressInteraction.Press -> {
+                    isLongPressClicked = false
+                    delay(viewConfiguration.longPressTimeoutMillis)
+                    currentOnLongClick?.let {
+                        isLongPressClicked = true
+                        hapticFeedback.performHapticFeedback(HapticFeedbackType.LongPress)
+                        it.invoke()
+                    }
+                }
+
+                is PressInteraction.Release -> {
+                    if (!isLongPressClicked) {
+                        currentOnClick()
+                    }
+                }
+            }
+        }
+    }
+
+    val colorScheme = MaterialTheme.colorScheme
+    val playerIconStyle = LocalPlayerIconStyle.current
+    val selectionBadgeBackgroundColor = colorScheme.primaryContainer
+    val selectionBadgeInactiveColor = colorScheme.surfaceContainerHighest
+    val customizeBorderColor = Color(0xFFFFEB3B)
+    val outlineBorderColor = colorScheme.primary.copy(alpha = 0.95f)
+    val outlineFillColor = colorScheme.primary.copy(alpha = 0.12f)
+    val customizeLabelColor = Color.White
+    val outlineLabelColor = colorScheme.primary.copy(alpha = 0.75f)
+    val selectionBadgeSize = if (buttonSize >= 56.dp) 20.dp else 18.dp
+    val selectionBadgeIconSize = if (buttonSize >= 56.dp) 13.dp else 12.dp
+
+    val buttonContent: @Composable () -> Unit = {
+        if (!isOutlineOnly) {
+            Box(
+                modifier = Modifier.fillMaxSize(),
+                contentAlignment = Alignment.Center,
+            ) {
+                content()
+            }
+        }
+    }
+
+    val outlineModifier = Modifier.drawBehind {
+        val strokeWidth = 1.5.dp.toPx()
+        drawCircle(
+            color = outlineFillColor,
+            radius = size.minDimension / 2f,
+        )
+        drawCircle(
+            color = outlineBorderColor,
+            style = Stroke(
+                width = strokeWidth,
+                pathEffect = PathEffect.dashPathEffect(
+                    intervals = floatArrayOf(12f, 12f),
+                ),
+            ),
+            radius = size.minDimension / 2f - (strokeWidth / 2f),
+        )
+    }
+
+    val whiteRippleConfiguration = RippleConfiguration(
+        color = Color.White,
+        rippleAlpha = RippleAlpha(
+            pressedAlpha = 0.5f,
+            focusedAlpha = 0.5f,
+            draggedAlpha = 0.5f,
+            hoveredAlpha = 0.5f,
+        ),
+    )
+
+    val buttonWithBadge: @Composable () -> Unit = {
+        Box(
+            modifier = Modifier.size(buttonSize),
+            contentAlignment = Alignment.Center,
+        ) {
+            when (playerIconStyle) {
+                PlayerIconStyle.CLASSIC -> {
+                    val backgroundModifier = if (isOutlineOnly) outlineModifier else Modifier
+                    CompositionLocalProvider(
+                        LocalContentColor provides if (isOutlineOnly) colorScheme.primary else Color.White,
+                        LocalRippleConfiguration provides whiteRippleConfiguration,
+                    ) {
+                        IconButton(
+                            onClick = {},
+                            enabled = isEnabled,
+                            modifier = Modifier.size(buttonSize).then(backgroundModifier),
+                            interactionSource = interactionSource,
+                            content = buttonContent,
+                        )
+                    }
+                }
+
+                PlayerIconStyle.TONAL, PlayerIconStyle.TRANSLUCENT -> {
+                    val containerColor = when {
+                        isOutlineOnly -> colorScheme.surface.copy(alpha = 0f)
+                        playerIconStyle == PlayerIconStyle.TRANSLUCENT -> colorScheme.primary.copy(alpha = 0.20f)
+                        else -> colorScheme.primary
+                    }
+                    val contentColor = when {
+                        isOutlineOnly -> colorScheme.primary
+                        playerIconStyle == PlayerIconStyle.TRANSLUCENT -> Color.White
+                        else -> colorScheme.onPrimary
+                    }
+                    FilledTonalIconButton(
+                        onClick = {},
+                        enabled = isEnabled,
+                        modifier = Modifier.size(buttonSize).then(if (isOutlineOnly) outlineModifier else Modifier),
+                        interactionSource = interactionSource,
+                        colors = IconButtonDefaults.filledTonalIconButtonColors(
+                            containerColor = containerColor,
+                            contentColor = contentColor,
+                            disabledContainerColor = colorScheme.surfaceContainerHighest.copy(alpha = 0.6f),
+                            disabledContentColor = colorScheme.onSurfaceVariant.copy(alpha = 0.6f),
+                        ),
+                        content = buttonContent,
+                    )
+                }
+            }
+
+            if (shouldShowSelectionBadge && !isOutlineOnly) {
+                Box(
+                    modifier = Modifier
+                        .align(Alignment.TopEnd)
+                        .size(selectionBadgeSize)
+                        .background(
+                            color = if (isSelected) selectionBadgeBackgroundColor else selectionBadgeInactiveColor,
+                            shape = CircleShape,
+                        ),
+                    contentAlignment = Alignment.Center,
+                ) {
+                    if (isSelected) {
+                        Icon(
+                            imageVector = NextIcons.Check,
+                            contentDescription = null,
+                            tint = colorScheme.primary,
+                            modifier = Modifier.size(selectionBadgeIconSize),
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    if (!isCustomizingButton) {
+        Box(
+            modifier = modifier,
+            contentAlignment = Alignment.Center,
+        ) {
+            buttonWithBadge()
+        }
+        return
+    }
+
+    Column(
+        modifier = modifier
+            .alpha(if (shouldDimWhenUnselected && !isSelected && !isOutlineOnly) 0.5f else 1f)
+            .widthIn(min = buttonSize + 16.dp, max = 88.dp)
+            .then(
+                if (shouldShowCustomizeFrame) {
+                    Modifier.drawBehind {
+                        val strokeWidth = 1.dp.toPx()
+                        drawRoundRect(
+                            color = if (isOutlineOnly) outlineBorderColor else customizeBorderColor,
+                            style = Stroke(
+                                width = strokeWidth,
+                                pathEffect = PathEffect.dashPathEffect(
+                                    intervals = floatArrayOf(12f, 12f),
+                                ),
+                            ),
+                            cornerRadius = androidx.compose.ui.geometry.CornerRadius(16.dp.toPx(), 16.dp.toPx()),
+                        )
+                        if (isOutlineOnly) {
+                            drawRoundRect(
+                                color = outlineFillColor,
+                                cornerRadius = androidx.compose.ui.geometry.CornerRadius(16.dp.toPx(), 16.dp.toPx()),
+                            )
+                        }
+                    }
+                } else {
+                    Modifier
+                },
+            )
+            .padding(horizontal = 6.dp, vertical = 6.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(2.dp),
+    ) {
+        buttonWithBadge()
+        Text(
+            text = label,
+            style = MaterialTheme.typography.labelSmall,
+            color = if (isOutlineOnly) outlineLabelColor else customizeLabelColor,
+            textAlign = TextAlign.Center,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/PreviousButton.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/PreviousButton.kt
new file mode 100644
index 000000000..3ffeff941
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/PreviousButton.kt
@@ -0,0 +1,53 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.buttons
+
+import androidx.annotation.OptIn
+import androidx.compose.foundation.layout.size
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.compose.state.rememberPreviousButtonState
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.feature.player.LocalControlsVisibilityState
+
+@OptIn(UnstableApi::class)
+@Composable
+internal fun PreviousButton(
+    player: Player,
+    modifier: Modifier = Modifier,
+    isSelected: Boolean = false,
+    label: String? = null,
+    isInteractive: Boolean = true,
+    onClick: (() -> Unit)? = null,
+) {
+    val state = rememberPreviousButtonState(player)
+    val controlsVisibilityState = LocalControlsVisibilityState.current
+
+    PlayerButton(
+        modifier = modifier,
+        buttonSize = 48.dp,
+        isEnabled = state.isEnabled,
+        isSelected = isSelected,
+        label = label,
+        isInteractive = isInteractive,
+        onClick = {
+            if (onClick != null) {
+                onClick()
+            } else {
+                state.onClick()
+                controlsVisibilityState?.showControls()
+            }
+        },
+    ) {
+        Icon(
+            imageVector = NextIcons.SkipPrevious,
+            contentDescription = stringResource(R.string.player_controls_previous),
+            modifier = Modifier.size(28.dp),
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/RepeatButton.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/RepeatButton.kt
new file mode 100644
index 000000000..bc4339931
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/RepeatButton.kt
@@ -0,0 +1,67 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.buttons
+
+import androidx.annotation.OptIn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.compose.state.rememberRepeatButtonState
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.feature.player.LocalControlsVisibilityState
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@OptIn(UnstableApi::class)
+@Composable
+fun LoopButton(
+    player: Player,
+    modifier: Modifier = Modifier,
+    isSelected: Boolean = false,
+    label: String? = null,
+    shouldDimWhenUnselected: Boolean = false,
+    shouldShowCustomizeFrame: Boolean = false,
+    isOutlineOnly: Boolean = false,
+    onClick: (() -> Unit)? = null,
+) {
+    val state = rememberRepeatButtonState(player)
+    val controlsVisibilityState = LocalControlsVisibilityState.current
+
+    PlayerButton(
+        modifier = modifier,
+        isEnabled = onClick != null || state.isEnabled,
+        isSelected = isSelected,
+        label = label,
+        shouldDimWhenUnselected = shouldDimWhenUnselected,
+        shouldShowCustomizeFrame = shouldShowCustomizeFrame,
+        isOutlineOnly = isOutlineOnly,
+        onClick = {
+            if (onClick != null) {
+                onClick()
+            } else {
+                state.onClick()
+                controlsVisibilityState?.showControls()
+            }
+        },
+    ) {
+        Icon(
+            imageVector = repeatModeIcon(state.repeatModeState),
+            contentDescription = repeatModeContentDescription(state.repeatModeState),
+        )
+    }
+}
+
+@Composable
+private fun repeatModeIcon(repeatMode: @Player.RepeatMode Int): AppIcon = when (repeatMode) {
+    Player.REPEAT_MODE_OFF -> NextIcons.Loop
+    Player.REPEAT_MODE_ONE -> NextIcons.LoopOne
+    else -> NextIcons.LoopAll
+}
+
+@Composable
+private fun repeatModeContentDescription(repeatMode: @Player.RepeatMode Int): String = when (repeatMode) {
+    Player.REPEAT_MODE_OFF -> stringResource(R.string.loop_mode_off)
+    Player.REPEAT_MODE_ONE -> stringResource(R.string.loop_mode_one)
+    else -> stringResource(R.string.loop_mode_all)
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/ShuffleButton.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/ShuffleButton.kt
new file mode 100644
index 000000000..4fa0cf950
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/buttons/ShuffleButton.kt
@@ -0,0 +1,53 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.buttons
+
+import androidx.annotation.OptIn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.compose.state.rememberShuffleButtonState
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.feature.player.LocalControlsVisibilityState
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@OptIn(UnstableApi::class)
+@Composable
+fun ShuffleButton(
+    player: Player,
+    modifier: Modifier = Modifier,
+    isSelected: Boolean = false,
+    label: String? = null,
+    shouldDimWhenUnselected: Boolean = false,
+    shouldShowCustomizeFrame: Boolean = false,
+    isOutlineOnly: Boolean = false,
+    onClick: (() -> Unit)? = null,
+) {
+    val state = rememberShuffleButtonState(player)
+    val controlsVisibilityState = LocalControlsVisibilityState.current
+
+    PlayerButton(
+        modifier = modifier,
+        isEnabled = onClick != null || state.isEnabled,
+        isSelected = isSelected,
+        label = label,
+        shouldDimWhenUnselected = shouldDimWhenUnselected,
+        shouldShowCustomizeFrame = shouldShowCustomizeFrame,
+        isOutlineOnly = isOutlineOnly,
+        onClick = {
+            if (onClick != null) {
+                onClick()
+            } else {
+                state.onClick()
+                controlsVisibilityState?.showControls()
+            }
+        },
+    ) {
+        Icon(
+            imageVector = if (state.shuffleOn) NextIcons.ShuffleOn else NextIcons.Shuffle,
+            contentDescription = stringResource(R.string.shuffle),
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/datasource/FtpDataSource.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/datasource/FtpDataSource.kt
new file mode 100644
index 000000000..355444f65
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/datasource/FtpDataSource.kt
@@ -0,0 +1,127 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.datasource
+
+import android.net.Uri
+import androidx.annotation.OptIn
+import androidx.media3.common.C
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.BaseDataSource
+import androidx.media3.datasource.DataSource
+import androidx.media3.datasource.DataSpec
+import java.io.IOException
+import java.io.InputStream
+import app.gyrolet.mpvrx.ui.browser.networkstreaming.clients.FtpClient
+import org.apache.commons.net.ftp.FTPClient
+
+@OptIn(UnstableApi::class)
+class FtpDataSource private constructor(
+    private val username: String,
+    private val password: String,
+) : BaseDataSource(true) {
+
+    private var client: FTPClient? = null
+    private var inputStream: InputStream? = null
+    private var uri: Uri? = null
+    private var bytesRemaining: Long = 0
+    private var hasStartedTransfer: Boolean = false
+
+    override fun open(dataSpec: DataSpec): Long {
+        uri = dataSpec.uri
+        transferInitializing(dataSpec)
+
+        val host = dataSpec.uri.host ?: throw IOException("FTP URI missing host")
+        val port = dataSpec.uri.port.takeIf { it > 0 } ?: 21
+        val path = dataSpec.uri.path?.ifBlank { null } ?: throw IOException("FTP URI missing path")
+
+        val ftpClient = FTPClient().apply {
+            connectTimeout = 10000
+            dataTimeout = java.time.Duration.ofMillis(30000)
+            setControlEncoding(Charsets.UTF_8.name())
+            setAutodetectUTF8(true)
+        }
+        client = ftpClient
+        try {
+            ftpClient.connect(host, port)
+            val loginOk = if (username.isBlank()) {
+                ftpClient.login("anonymous", "")
+            } else {
+                ftpClient.login(username, password)
+            }
+            if (!loginOk) throw IOException("FTP login failed")
+
+            ftpClient.enterLocalPassiveMode()
+            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE)
+            val fileSize = ftpClient.mlistFile(path)?.size ?: C.LENGTH_UNSET.toLong()
+            if (dataSpec.position > 0) {
+                ftpClient.setRestartOffset(dataSpec.position)
+            }
+
+            val stream = ftpClient.retrieveFileStream(path) ?: throw IOException("FTP retrieve failed: $path")
+            inputStream = stream
+            bytesRemaining = when {
+                dataSpec.length != C.LENGTH_UNSET.toLong() -> dataSpec.length
+                fileSize != C.LENGTH_UNSET.toLong() -> fileSize - dataSpec.position
+                else -> C.LENGTH_UNSET.toLong()
+            }
+
+            transferStarted(dataSpec)
+            hasStartedTransfer = true
+            return bytesRemaining
+        } catch (exception: IOException) {
+            close()
+            throw exception
+        } catch (exception: RuntimeException) {
+            close()
+            throw exception
+        }
+    }
+
+    override fun read(buffer: ByteArray, offset: Int, length: Int): Int {
+        if (bytesRemaining == 0L) return C.RESULT_END_OF_INPUT
+
+        val bytesToRead = if (bytesRemaining == C.LENGTH_UNSET.toLong()) {
+            length
+        } else {
+            minOf(length.toLong(), bytesRemaining).toInt()
+        }
+        val bytesRead = inputStream?.read(buffer, offset, bytesToRead)
+            ?: return C.RESULT_END_OF_INPUT
+        if (bytesRead == -1) return C.RESULT_END_OF_INPUT
+
+        if (bytesRemaining != C.LENGTH_UNSET.toLong()) {
+            bytesRemaining -= bytesRead
+        }
+        bytesTransferred(bytesRead)
+        return bytesRead
+    }
+
+    override fun getUri(): Uri? = uri
+
+    override fun close() {
+        val shouldCompletePendingCommand = inputStream != null
+        runCatching { inputStream?.close() }
+        if (shouldCompletePendingCommand) {
+            runCatching { client?.completePendingCommand() }
+        }
+        runCatching {
+            if (client?.isConnected == true) client?.logout()
+        }
+        runCatching {
+            if (client?.isConnected == true) client?.disconnect()
+        }
+        inputStream = null
+        client = null
+        uri = null
+        bytesRemaining = 0
+        if (hasStartedTransfer) {
+            hasStartedTransfer = false
+            transferEnded()
+        }
+    }
+
+    class Factory(
+        private val username: String,
+        private val password: String,
+    ) : DataSource.Factory {
+        override fun createDataSource(): FtpDataSource = FtpDataSource(username, password)
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/datasource/SmbDataSource.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/datasource/SmbDataSource.kt
new file mode 100644
index 000000000..55357f6c0
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/datasource/SmbDataSource.kt
@@ -0,0 +1,162 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.datasource
+
+import android.net.Uri
+import androidx.annotation.OptIn
+import androidx.media3.common.C
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.BaseDataSource
+import androidx.media3.datasource.DataSource
+import androidx.media3.datasource.DataSpec
+import com.hierynomus.msdtyp.AccessMask
+import com.hierynomus.msfscc.FileAttributes
+import com.hierynomus.mssmb2.SMB2CreateDisposition
+import com.hierynomus.mssmb2.SMB2ShareAccess
+import com.hierynomus.smbj.SMBClient
+import com.hierynomus.smbj.SmbConfig
+import com.hierynomus.smbj.auth.AuthenticationContext
+import com.hierynomus.smbj.share.DiskShare
+import java.io.IOException
+import java.io.InputStream
+import java.util.EnumSet
+import java.util.concurrent.TimeUnit
+
+@OptIn(UnstableApi::class)
+class SmbDataSource private constructor(
+    private val username: String,
+    private val password: String,
+) : BaseDataSource(true) {
+
+    private var client: SMBClient? = null
+    private var share: DiskShare? = null
+    private var smbFile: com.hierynomus.smbj.share.File? = null
+    private var inputStream: InputStream? = null
+    private var uri: Uri? = null
+    private var bytesRemaining: Long = 0
+    private var hasStartedTransfer: Boolean = false
+
+    override fun open(dataSpec: DataSpec): Long {
+        uri = dataSpec.uri
+        transferInitializing(dataSpec)
+
+        val host = dataSpec.uri.host ?: throw IOException("SMB URI missing host")
+        val port = dataSpec.uri.port.takeIf { it > 0 } ?: DEFAULT_PORT
+        val pathSegments = dataSpec.uri.pathSegments
+        if (pathSegments.size < 2) throw IOException("SMB URI path too short: ${dataSpec.uri}")
+
+        val shareName = pathSegments.first()
+        val filePath = pathSegments.drop(1).joinToString("\\")
+
+        val config = SmbConfig.builder()
+            .withTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+            .withSoTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+            .build()
+
+        val smbClient = SMBClient(config)
+        client = smbClient
+
+        val connection = smbClient.connect(host, port)
+        val authContext = toAuthenticationContext(username, password)
+        val session = connection.authenticate(authContext)
+        val diskShare = session.connectShare(shareName) as DiskShare
+        share = diskShare
+
+        val file = diskShare.openFile(
+            filePath,
+            EnumSet.of(AccessMask.GENERIC_READ),
+            EnumSet.of(FileAttributes.FILE_ATTRIBUTE_NORMAL),
+            SMB2ShareAccess.ALL,
+            SMB2CreateDisposition.FILE_OPEN,
+            EnumSet.noneOf(com.hierynomus.mssmb2.SMB2CreateOptions::class.java),
+        )
+        smbFile = file
+
+        val fileSize = file.fileInformation.standardInformation.endOfFile
+        val stream = file.inputStream
+
+        if (dataSpec.position > 0) {
+            var remaining = dataSpec.position
+            while (remaining > 0) {
+                val skipped = stream.skip(remaining)
+                if (skipped <= 0) break
+                remaining -= skipped
+            }
+        }
+        inputStream = stream
+
+        bytesRemaining = if (dataSpec.length != C.LENGTH_UNSET.toLong()) {
+            dataSpec.length
+        } else {
+            fileSize - dataSpec.position
+        }
+
+        transferStarted(dataSpec)
+        hasStartedTransfer = true
+        return bytesRemaining
+    }
+
+    override fun read(buffer: ByteArray, offset: Int, length: Int): Int {
+        if (bytesRemaining == 0L) return C.RESULT_END_OF_INPUT
+
+        val bytesToRead = minOf(length.toLong(), bytesRemaining).toInt()
+        val bytesRead = inputStream?.read(buffer, offset, bytesToRead)
+            ?: return C.RESULT_END_OF_INPUT
+        if (bytesRead == -1) return C.RESULT_END_OF_INPUT
+
+        bytesRemaining -= bytesRead
+        bytesTransferred(bytesRead)
+        return bytesRead
+    }
+
+    override fun getUri(): Uri? = uri
+
+    override fun close() {
+        try {
+            inputStream?.close()
+        } catch (_: Exception) {
+        }
+        try {
+            smbFile?.close()
+        } catch (_: Exception) {
+        }
+        try {
+            share?.close()
+        } catch (_: Exception) {
+        }
+        try {
+            client?.close()
+        } catch (_: Exception) {
+        }
+        inputStream = null
+        smbFile = null
+        share = null
+        client = null
+        uri = null
+        bytesRemaining = 0
+        if (hasStartedTransfer) {
+            hasStartedTransfer = false
+            transferEnded()
+        }
+    }
+
+    class Factory(
+        private val username: String,
+        private val password: String,
+    ) : DataSource.Factory {
+        override fun createDataSource(): SmbDataSource = SmbDataSource(username, password)
+    }
+
+    companion object {
+        private const val DEFAULT_PORT = 445
+        private const val TIMEOUT_SECONDS = 30L
+
+        private fun toAuthenticationContext(username: String, password: String): AuthenticationContext {
+            if (username.isBlank()) return AuthenticationContext.anonymous()
+
+            val domain = username.substringBefore('\\', missingDelimiterValue = "")
+                .substringBefore('/', missingDelimiterValue = "")
+            val account = username.substringAfterLast('\\').substringAfterLast('/')
+
+            return AuthenticationContext(account, password.toCharArray(), domain)
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/engine/media3/MkvCuesParser.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/engine/media3/MkvCuesParser.kt
new file mode 100644
index 000000000..c1884f2df
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/engine/media3/MkvCuesParser.kt
@@ -0,0 +1,433 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.engine.media3
+
+import android.content.ContentResolver
+import android.content.Context
+import android.net.Uri
+import java.io.IOException
+import java.io.RandomAccessFile
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.getPath
+
+// MKV Cues 预解析结果
+data class MkvCuePoint(
+    val timeUs: Long,
+    val clusterPosition: Long,
+)
+
+// 轻量级 EBML 解析器，仅读取 SeekHead + Cues
+// 使用 RandomAccessFile + 256KB 读取缓冲，大文件耗时 < 1 秒
+object MkvCuesParser {
+
+    private const val TAG = "MkvCuesParser"
+    internal const val BUFFER_SIZE = 256 * 1024
+    private const val MAX_CUE_POINTS = 10_000
+
+    // EBML 元素 ID
+    private const val ID_EBML: Long = 0x1A45DFA3
+    private const val ID_SEGMENT: Long = 0x18538067
+    private const val ID_SEEK_HEAD: Long = 0x114D9B74
+    private const val ID_SEEK: Long = 0x4DBB
+    private const val ID_SEEK_ID: Long = 0x53AB
+    private const val ID_SEEK_POSITION: Long = 0x53AC
+    private const val ID_INFO: Long = 0x1549A966
+    private const val ID_TIMESTAMP_SCALE: Long = 0x2AD7B1
+    private const val ID_CUES: Long = 0x1C53BB6B
+    private const val ID_CUE_POINT: Long = 0xBB
+    private const val ID_CUE_TIME: Long = 0xB3
+    private const val ID_CUE_TRACK_POSITIONS: Long = 0xB7
+    private const val ID_CUE_CLUSTER_POSITION: Long = 0xF1
+
+    fun parse(context: Context, uri: Uri): List<MkvCuePoint>? = try {
+        when (uri.scheme) {
+            ContentResolver.SCHEME_CONTENT -> parseContent(context, uri)
+            ContentResolver.SCHEME_FILE -> parseFile(uri.path!!)
+            else -> getPath(context, uri)?.let(::parseFile)
+        }
+    } catch (e: Exception) {
+        Logger.error(TAG, "Failed to parse MKV Cues", e)
+        null
+    }
+
+    private fun parseFile(path: String): List<MkvCuePoint>? {
+        RandomAccessFile(path, "r").use { raf ->
+            return parseWithReader(BufferedRandomReader(raf))
+        }
+    }
+
+    private fun parseContent(context: Context, uri: Uri): List<MkvCuePoint>? {
+        val pfd = context.contentResolver.openFileDescriptor(uri, "r") ?: return null
+        return pfd.use {
+            java.io.FileInputStream(it.fileDescriptor).use { fis ->
+                val channel = fis.channel
+                return parseWithReader(BufferedChannelReader(channel))
+            }
+        }
+    }
+
+    private fun parseWithReader(reader: BufferedReader): List<MkvCuePoint>? {
+        // 跳过 EBML 头
+        val ebmlHeader = reader.readElementHeader() ?: return null
+        if (ebmlHeader.id != ID_EBML) return null
+        reader.skip(ebmlHeader.dataSize)
+
+        // 读取 Segment 头
+        val segmentHeader = reader.readElementHeader() ?: return null
+        if (segmentHeader.id != ID_SEGMENT) return null
+        val segmentDataStart = reader.position()
+
+        // 扫描 Segment 子元素：SeekHead + Info
+        var cuesPosition: Long? = null
+        var timestampScale = 1_000_000L // 默认 1ms = 1_000_000ns
+        val scanEnd = minOf(segmentDataStart + segmentHeader.dataSize, reader.fileSize())
+
+        while (reader.position() < scanEnd) {
+            val header = reader.readElementHeader() ?: break
+
+            when (header.id) {
+                ID_SEEK_HEAD -> {
+                    val seekHeadEnd = reader.position() + header.dataSize
+                    val parsedCuesPos = parseSeekHead(reader, seekHeadEnd, segmentDataStart)
+                    if (parsedCuesPos != null) cuesPosition = parsedCuesPos
+                }
+                ID_INFO -> {
+                    val infoEnd = reader.position() + header.dataSize
+                    while (reader.position() < infoEnd) {
+                        val infoChild = reader.readElementHeader() ?: break
+                        when (infoChild.id) {
+                            ID_TIMESTAMP_SCALE -> timestampScale = reader.readUint(infoChild.dataSize)
+                            else -> reader.skip(infoChild.dataSize)
+                        }
+                    }
+                }
+                else -> {
+                    // 遇到 Cluster 等大元素时停止扫描头部
+                    if (cuesPosition != null) break
+                    reader.skip(header.dataSize)
+                }
+            }
+        }
+
+        if (cuesPosition == null) {
+            Logger.debug(TAG, "No Cues position found in SeekHead")
+            return null
+        }
+
+        // 直接跳到 Cues 位置
+        reader.seek(cuesPosition)
+        val cuesHeader = reader.readElementHeader() ?: return null
+        if (cuesHeader.id != ID_CUES) {
+            Logger.error(TAG, "Expected Cues at $cuesPosition, got 0x${cuesHeader.id.toString(16)}")
+            return null
+        }
+
+        val cues = parseCues(reader, reader.position() + cuesHeader.dataSize, timestampScale, segmentDataStart)
+        if (cues.isEmpty()) return null
+
+        Logger.debug(TAG, "Parsed ${cues.size} cue points (max=$MAX_CUE_POINTS), timestampScale=$timestampScale")
+        return cues
+    }
+
+    private fun parseSeekHead(
+        reader: BufferedReader,
+        seekHeadEnd: Long,
+        segmentDataStart: Long,
+    ): Long? {
+        var cuesPosition: Long? = null
+        while (reader.position() < seekHeadEnd) {
+            val header = reader.readElementHeader() ?: break
+            if (header.id != ID_SEEK) {
+                reader.skip(header.dataSize)
+                continue
+            }
+
+            val seekEnd = reader.position() + header.dataSize
+            var seekId: Long? = null
+            var seekPosition: Long? = null
+
+            while (reader.position() < seekEnd) {
+                val child = reader.readElementHeader() ?: break
+                when (child.id) {
+                    ID_SEEK_ID -> seekId = reader.readUint(child.dataSize)
+                    ID_SEEK_POSITION -> seekPosition = reader.readUint(child.dataSize)
+                    else -> reader.skip(child.dataSize)
+                }
+            }
+
+            if (seekId == ID_CUES && seekPosition != null) {
+                cuesPosition = segmentDataStart + seekPosition
+            }
+        }
+        return cuesPosition
+    }
+
+    // 两阶段解析：先计数再按采样步长收集，避免分配 80 万个临时对象导致 OOM
+    private fun parseCues(
+        reader: BufferedReader,
+        cuesEnd: Long,
+        timestampScale: Long,
+        segmentDataStart: Long,
+    ): List<MkvCuePoint> {
+        // 第一阶段，快速扫描计数，只读元素头并跳过数据
+        val cuesStart = reader.position()
+        var totalCount = 0
+        while (reader.position() < cuesEnd) {
+            val header = reader.readElementHeader() ?: break
+            if (header.id == ID_CUE_POINT) totalCount++
+            reader.skip(header.dataSize)
+        }
+        if (totalCount == 0) return emptyList()
+
+        // 计算采样步长：超过上限时均匀跳过
+        val step = if (totalCount > MAX_CUE_POINTS) {
+            totalCount.toDouble() / MAX_CUE_POINTS
+        } else {
+            1.0
+        }
+        val expectedSize = minOf(totalCount, MAX_CUE_POINTS)
+
+        // 第二阶段：回到起点，按步长只解析需要保留的 CuePoint
+        reader.seek(cuesStart)
+        val cuePoints = ArrayList<MkvCuePoint>(expectedSize)
+        var index = 0
+        var nextKeepIndex = 0.0
+
+        while (reader.position() < cuesEnd) {
+            val header = reader.readElementHeader() ?: break
+            if (header.id != ID_CUE_POINT) {
+                reader.skip(header.dataSize)
+                continue
+            }
+
+            val shouldKeep = index >= nextKeepIndex.toInt()
+            if (!shouldKeep) {
+                reader.skip(header.dataSize)
+                index++
+                continue
+            }
+
+            val cueEnd = reader.position() + header.dataSize
+            var cueTime: Long? = null
+            var clusterPosition: Long? = null
+
+            while (reader.position() < cueEnd) {
+                val child = reader.readElementHeader() ?: break
+                when (child.id) {
+                    ID_CUE_TIME -> cueTime = reader.readUint(child.dataSize)
+                    ID_CUE_TRACK_POSITIONS -> {
+                        val posEnd = reader.position() + child.dataSize
+                        while (reader.position() < posEnd) {
+                            val posChild = reader.readElementHeader() ?: break
+                            when (posChild.id) {
+                                ID_CUE_CLUSTER_POSITION -> {
+                                    if (clusterPosition == null) {
+                                        clusterPosition = reader.readUint(posChild.dataSize)
+                                    } else {
+                                        reader.skip(posChild.dataSize)
+                                    }
+                                }
+                                else -> reader.skip(posChild.dataSize)
+                            }
+                        }
+                    }
+                    else -> reader.skip(child.dataSize)
+                }
+            }
+
+            if (cueTime != null && clusterPosition != null) {
+                val timeUs = cueTime * timestampScale / 1_000L
+                val absolutePosition = segmentDataStart + clusterPosition
+                cuePoints.add(MkvCuePoint(timeUs = timeUs, clusterPosition = absolutePosition))
+                nextKeepIndex += step
+            }
+            index++
+        }
+        return cuePoints
+    }
+
+    // 从 content:// URI 解析文件路径
+    private fun getPath(context: Context, uri: Uri): String? = try {
+        context.getPath(uri)
+    } catch (_: Exception) {
+        null
+    }
+}
+
+// 带缓冲的读取器接口
+private interface BufferedReader {
+    fun position(): Long
+    fun fileSize(): Long
+    fun seek(position: Long)
+    fun skip(size: Long)
+    fun readByte(): Int
+    fun readBytes(count: Int): ByteArray
+
+    fun readElementHeader(): ElementHeader? {
+        val id = readVint(withLengthBits = true) ?: return null
+        val dataSize = readVint(withLengthBits = false) ?: return null
+        return ElementHeader(id, dataSize)
+    }
+
+    fun readUint(size: Long): Long {
+        if (size > 8) throw IOException("uint too large: $size")
+        var value = 0L
+        for (i in 0 until size.toInt()) {
+            val b = readByte()
+            if (b == -1) throw IOException("Unexpected EOF")
+            value = (value shl 8) or b.toLong()
+        }
+        return value
+    }
+
+    // 读取 EBML 变长整数
+    // withLengthBits=true 保留长度位，false 清除长度位
+    fun readVint(withLengthBits: Boolean): Long? {
+        val firstByte = readByte()
+        if (firstByte == -1 || firstByte == 0) return null
+
+        val length = Integer.numberOfLeadingZeros(firstByte) - 23
+        if (length < 1 || length > 8) return null
+
+        var value = if (withLengthBits) {
+            firstByte.toLong()
+        } else {
+            (firstByte.toLong() and ((1L shl (8 - length)) - 1))
+        }
+
+        for (i in 1 until length) {
+            val b = readByte()
+            if (b == -1) return null
+            value = (value shl 8) or b.toLong()
+        }
+
+        return value
+    }
+}
+
+// 基于 RandomAccessFile 的带缓冲读取器
+// 256KB 缓冲减少系统调用，seek 操作清空缓冲区重新填充
+private class BufferedRandomReader(private val raf: RandomAccessFile) : BufferedReader {
+
+    private val buffer = ByteArray(MkvCuesParser.BUFFER_SIZE)
+    private var bufferOffset = 0L // buffer[0] 对应的文件偏移
+    private var bufferLength = 0 // buffer 中有效数据长度
+    private var bufferPos = 0 // buffer 中当前读取位置
+
+    override fun position(): Long = bufferOffset + bufferPos
+    override fun fileSize(): Long = raf.length()
+
+    override fun seek(position: Long) {
+        // 如果目标位置在当前缓冲区内，直接移动指针
+        val relativePos = position - bufferOffset
+        if (relativePos in 0 until bufferLength) {
+            bufferPos = relativePos.toInt()
+            return
+        }
+        raf.seek(position)
+        bufferOffset = position
+        bufferLength = 0
+        bufferPos = 0
+    }
+
+    override fun skip(size: Long) {
+        seek(position() + size)
+    }
+
+    override fun readByte(): Int {
+        if (bufferPos >= bufferLength) {
+            fillBuffer()
+            if (bufferLength == 0) return -1
+        }
+        return buffer[bufferPos++].toInt() and 0xFF
+    }
+
+    override fun readBytes(count: Int): ByteArray {
+        val result = ByteArray(count)
+        var offset = 0
+        while (offset < count) {
+            if (bufferPos >= bufferLength) {
+                fillBuffer()
+                if (bufferLength == 0) throw IOException("Unexpected EOF")
+            }
+            val available = bufferLength - bufferPos
+            val toCopy = minOf(available, count - offset)
+            System.arraycopy(buffer, bufferPos, result, offset, toCopy)
+            bufferPos += toCopy
+            offset += toCopy
+        }
+        return result
+    }
+
+    private fun fillBuffer() {
+        bufferOffset += bufferPos
+        raf.seek(bufferOffset)
+        bufferLength = raf.read(buffer)
+        if (bufferLength == -1) bufferLength = 0
+        bufferPos = 0
+    }
+}
+
+// 基于 FileChannel 的带缓冲读取器（用于 content:// URI 回退路径）
+private class BufferedChannelReader(
+    private val channel: java.nio.channels.FileChannel,
+) : BufferedReader {
+
+    private val buffer = ByteArray(MkvCuesParser.BUFFER_SIZE)
+    private var bufferOffset = 0L
+    private var bufferLength = 0
+    private var bufferPos = 0
+
+    override fun position(): Long = bufferOffset + bufferPos
+    override fun fileSize(): Long = channel.size()
+
+    override fun seek(position: Long) {
+        val relativePos = position - bufferOffset
+        if (relativePos in 0 until bufferLength) {
+            bufferPos = relativePos.toInt()
+            return
+        }
+        channel.position(position)
+        bufferOffset = position
+        bufferLength = 0
+        bufferPos = 0
+    }
+
+    override fun skip(size: Long) {
+        seek(position() + size)
+    }
+
+    override fun readByte(): Int {
+        if (bufferPos >= bufferLength) {
+            fillBuffer()
+            if (bufferLength == 0) return -1
+        }
+        return buffer[bufferPos++].toInt() and 0xFF
+    }
+
+    override fun readBytes(count: Int): ByteArray {
+        val result = ByteArray(count)
+        var offset = 0
+        while (offset < count) {
+            if (bufferPos >= bufferLength) {
+                fillBuffer()
+                if (bufferLength == 0) throw IOException("Unexpected EOF")
+            }
+            val available = bufferLength - bufferPos
+            val toCopy = minOf(available, count - offset)
+            System.arraycopy(buffer, bufferPos, result, offset, toCopy)
+            bufferPos += toCopy
+            offset += toCopy
+        }
+        return result
+    }
+
+    private fun fillBuffer() {
+        bufferOffset += bufferPos
+        channel.position(bufferOffset)
+        val bb = java.nio.ByteBuffer.wrap(buffer)
+        bufferLength = channel.read(bb)
+        if (bufferLength == -1) bufferLength = 0
+        bufferPos = 0
+    }
+}
+
+private data class ElementHeader(val id: Long, val dataSize: Long)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/engine/media3/SeekMapInjectingExtractor.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/engine/media3/SeekMapInjectingExtractor.kt
new file mode 100644
index 000000000..517f5a3c3
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/engine/media3/SeekMapInjectingExtractor.kt
@@ -0,0 +1,70 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.engine.media3
+
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.extractor.Extractor
+import androidx.media3.extractor.ExtractorInput
+import androidx.media3.extractor.ExtractorOutput
+import androidx.media3.extractor.IndexSeekMap
+import androidx.media3.extractor.PositionHolder
+import androidx.media3.extractor.SeekMap
+import androidx.media3.extractor.SniffFailure
+import androidx.media3.extractor.TrackOutput
+
+// 包装 Extractor，拦截 seekMap() 回调
+// 当原始 extractor 提供 Unseekable SeekMap 时，替换为预解析的 IndexSeekMap
+@OptIn(UnstableApi::class)
+class SeekMapInjectingExtractor(
+    private val delegate: Extractor,
+    private val precomputedSeekMap: SeekMap?,
+) : Extractor {
+
+    override fun sniff(input: ExtractorInput): Boolean = delegate.sniff(input)
+
+    override fun getSniffFailureDetails(): List<SniffFailure> = delegate.sniffFailureDetails
+
+    override fun init(output: ExtractorOutput) {
+        if (precomputedSeekMap != null) {
+            delegate.init(SeekMapInterceptingOutput(output, precomputedSeekMap))
+        } else {
+            delegate.init(output)
+        }
+    }
+
+    override fun read(input: ExtractorInput, seekPosition: PositionHolder): Int = delegate.read(input, seekPosition)
+
+    override fun seek(position: Long, timeUs: Long) = delegate.seek(position, timeUs)
+
+    override fun release() = delegate.release()
+
+    override fun getUnderlyingImplementation(): Extractor = delegate.underlyingImplementation
+}
+
+@OptIn(UnstableApi::class)
+private class SeekMapInterceptingOutput(
+    private val delegate: ExtractorOutput,
+    private val precomputedSeekMap: SeekMap,
+) : ExtractorOutput {
+
+    override fun track(id: Int, type: Int): TrackOutput = delegate.track(id, type)
+
+    override fun endTracks() = delegate.endTracks()
+
+    override fun seekMap(seekMap: SeekMap) {
+        // 原始 extractor（seekForCuesEnabled=false）提供 Unseekable SeekMap
+        // 替换为预解析的 seekable SeekMap
+        if (!seekMap.isSeekable) {
+            delegate.seekMap(precomputedSeekMap)
+        } else {
+            delegate.seekMap(seekMap)
+        }
+    }
+}
+
+// 从预解析的 Cues 构建 IndexSeekMap
+@OptIn(UnstableApi::class)
+fun buildSeekMapFromCues(cuePoints: List<MkvCuePoint>, durationUs: Long): IndexSeekMap {
+    val timesUs = LongArray(cuePoints.size) { cuePoints[it].timeUs }
+    val positions = LongArray(cuePoints.size) { cuePoints[it].clusterPosition }
+    return IndexSeekMap(positions, timesUs, durationUs)
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Activity.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Activity.kt
new file mode 100644
index 000000000..0e6bcf7ab
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Activity.kt
@@ -0,0 +1,41 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import android.app.Activity
+import android.provider.Settings
+import android.view.WindowManager
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsCompat.Type
+import androidx.core.view.WindowInsetsControllerCompat
+
+fun Activity.swipeToShowStatusBars() {
+    WindowCompat.getInsetsController(window, window.decorView).systemBarsBehavior =
+        WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+}
+
+fun Activity.toggleSystemBars(shouldShowBars: Boolean, @Type.InsetsType types: Int = Type.systemBars()) {
+    WindowCompat.getInsetsController(window, window.decorView).apply {
+        systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        if (shouldShowBars) show(types) else hide(types)
+    }
+}
+
+fun Activity.togglePlayerSystemBars(shouldShowControls: Boolean) {
+    WindowCompat.getInsetsController(window, window.decorView).apply {
+        systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        if (shouldShowControls) {
+            show(WindowInsetsCompat.Type.systemBars())
+        } else {
+            hide(WindowInsetsCompat.Type.systemBars())
+        }
+    }
+}
+
+val Activity.currentBrightness: Float
+    get() = when (val brightness = window.attributes.screenBrightness) {
+        in WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_OFF..WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_FULL -> brightness
+        else -> Settings.System.getFloat(contentResolver, Settings.System.SCREEN_BRIGHTNESS) / 255
+    }
+
+val Activity.brightnessPercentage: Int
+    get() = (currentBrightness / WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_FULL * 100).toInt()
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Duration.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Duration.kt
new file mode 100644
index 000000000..f437a89ae
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Duration.kt
@@ -0,0 +1,13 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import kotlin.time.Duration
+
+fun Duration.formatted(): String = toComponents { hours, minutes, seconds, _ ->
+    if (hours > 0) {
+        "$hours:${minutes.padStartWith0()}:${seconds.padStartWith0()}"
+    } else {
+        "${minutes.padStartWith0()}:${seconds.padStartWith0()}"
+    }
+}
+
+private fun Number.padStartWith0() = this.toString().padStart(2, '0')
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Enum.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Enum.kt
new file mode 100644
index 000000000..824c32206
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Enum.kt
@@ -0,0 +1,7 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+inline fun <reified T : Enum<T>> T.next(): T {
+    val values = enumValues<T>()
+    val nextOrdinal = (ordinal + 1) % values.size
+    return values[nextOrdinal]
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Font.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Font.kt
new file mode 100644
index 000000000..34df0d91c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Font.kt
@@ -0,0 +1,11 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import android.graphics.Typeface
+import app.gyrolet.mpvrx.exoplayer.core.model.Font
+
+fun Font.toTypeface(): Typeface = when (this) {
+    Font.DEFAULT -> Typeface.DEFAULT
+    Font.MONOSPACE -> Typeface.MONOSPACE
+    Font.SANS_SERIF -> Typeface.SANS_SERIF
+    Font.SERIF -> Typeface.SERIF
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/ImageButton.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/ImageButton.kt
new file mode 100644
index 000000000..e2690c315
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/ImageButton.kt
@@ -0,0 +1,9 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import android.content.Context
+import android.widget.ImageButton
+import androidx.core.content.ContextCompat
+
+fun ImageButton.setImageDrawable(context: Context, id: Int) {
+    setImageDrawable(ContextCompat.getDrawable(context, id))
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/MappedTrackInfo.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/MappedTrackInfo.kt
new file mode 100644
index 000000000..5a7763765
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/MappedTrackInfo.kt
@@ -0,0 +1,16 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import androidx.media3.common.C
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.trackselection.MappingTrackSelector
+
+@UnstableApi
+fun MappingTrackSelector.MappedTrackInfo.isRendererAvailable(
+    type: @C.TrackType Int,
+): Boolean {
+    for (i in 0 until rendererCount) {
+        if (getTrackGroups(i).length == 0) continue
+        if (type == getRendererType(i)) return true
+    }
+    return false
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/MediaItem.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/MediaItem.kt
new file mode 100644
index 000000000..653a19d47
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/MediaItem.kt
@@ -0,0 +1,262 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import android.os.Bundle
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+
+private const val MEDIA_METADATA_POSITION_KEY = "media_metadata_position"
+private const val MEDIA_METADATA_PLAYBACK_SPEED_KEY = "media_metadata_playback_speed"
+private const val MEDIA_METADATA_AUDIO_TRACK_INDEX_KEY = "audio_track_index"
+private const val MEDIA_METADATA_SUBTITLE_TRACK_INDEX_KEY = "subtitle_track_index"
+private const val MEDIA_METADATA_VIDEO_ZOOM_KEY = "media_metadata_video_zoom"
+private const val MEDIA_METADATA_SUBTITLE_DELAY_KEY = "media_metadata_subtitle_delay"
+private const val MEDIA_METADATA_SUBTITLE_SPEED_KEY = "media_metadata_subtitle_speed"
+private const val MEDIA_METADATA_VIDEO_WIDTH_KEY = "media_metadata_video_width"
+private const val MEDIA_METADATA_VIDEO_HEIGHT_KEY = "media_metadata_video_height"
+private const val MEDIA_METADATA_VIDEO_ROTATION_KEY = "media_metadata_video_rotation"
+private const val MEDIA_METADATA_HAS_RENDERED_FIRST_FRAME_KEY = "media_metadata_has_rendered_first_frame"
+private const val MEDIA_METADATA_APPROXIMATE_SEEK_ENABLED_KEY = "media_metadata_approximate_seek_enabled"
+private const val MEDIA_METADATA_VIDEO_EFFECTS_AVAILABLE_KEY = "media_metadata_video_effects_available"
+private const val MEDIA_METADATA_REQUEST_HEADERS_PREFIX = "media_metadata_request_header_"
+private const val MEDIA_METADATA_REMOTE_SERVER_ID_KEY = "media_metadata_remote_server_id"
+private const val MEDIA_METADATA_REMOTE_FILE_PATH_KEY = "media_metadata_remote_file_path"
+private const val MEDIA_METADATA_REMOTE_PROTOCOL_KEY = "media_metadata_remote_protocol"
+private const val MEDIA_METADATA_LOCAL_PARENT_PATH_KEY = "media_metadata_local_parent_path"
+private const val MEDIA_METADATA_REMOTE_DIRECTORY_PATH_KEY = "media_metadata_remote_directory_path"
+
+internal fun Bundle.setExtras(
+    positionMs: Long?,
+    videoScale: Float?,
+    playbackSpeed: Float?,
+    audioTrackIndex: Int?,
+    subtitleTrackIndex: Int?,
+    subtitleDelayMilliseconds: Long? = null,
+    subtitleSpeed: Float? = null,
+    videoWidth: Int? = null,
+    videoHeight: Int? = null,
+    videoRotation: Int? = null,
+    hasRenderedFirstFrame: Boolean? = null,
+    isApproximateSeekEnabled: Boolean? = null,
+    isVideoEffectsAvailable: Boolean? = null,
+    remoteServerId: Long? = null,
+    remoteFilePath: String? = null,
+    remoteProtocol: String? = null,
+    localParentPath: String? = null,
+    remoteDirectoryPath: String? = null,
+) = apply {
+    positionMs?.let { putLong(MEDIA_METADATA_POSITION_KEY, it) }
+    videoScale?.let { putFloat(MEDIA_METADATA_VIDEO_ZOOM_KEY, it) }
+    playbackSpeed?.let { putFloat(MEDIA_METADATA_PLAYBACK_SPEED_KEY, it) }
+    audioTrackIndex?.let { putInt(MEDIA_METADATA_AUDIO_TRACK_INDEX_KEY, it) }
+    subtitleTrackIndex?.let { putInt(MEDIA_METADATA_SUBTITLE_TRACK_INDEX_KEY, it) }
+    subtitleDelayMilliseconds?.let { putLong(MEDIA_METADATA_SUBTITLE_DELAY_KEY, it) }
+    subtitleSpeed?.let { putFloat(MEDIA_METADATA_SUBTITLE_SPEED_KEY, it) }
+    videoWidth?.let { putInt(MEDIA_METADATA_VIDEO_WIDTH_KEY, it) }
+    videoHeight?.let { putInt(MEDIA_METADATA_VIDEO_HEIGHT_KEY, it) }
+    videoRotation?.let { putInt(MEDIA_METADATA_VIDEO_ROTATION_KEY, it) }
+    hasRenderedFirstFrame?.let { putBoolean(MEDIA_METADATA_HAS_RENDERED_FIRST_FRAME_KEY, it) }
+    isApproximateSeekEnabled?.let { putBoolean(MEDIA_METADATA_APPROXIMATE_SEEK_ENABLED_KEY, it) }
+    isVideoEffectsAvailable?.let { putBoolean(MEDIA_METADATA_VIDEO_EFFECTS_AVAILABLE_KEY, it) }
+    remoteServerId?.let { putLong(MEDIA_METADATA_REMOTE_SERVER_ID_KEY, it) }
+    remoteFilePath?.let { putString(MEDIA_METADATA_REMOTE_FILE_PATH_KEY, it) }
+    remoteProtocol?.let { putString(MEDIA_METADATA_REMOTE_PROTOCOL_KEY, it) }
+    localParentPath?.let { putString(MEDIA_METADATA_LOCAL_PARENT_PATH_KEY, it) }
+    remoteDirectoryPath?.let { putString(MEDIA_METADATA_REMOTE_DIRECTORY_PATH_KEY, it) }
+}
+
+fun MediaMetadata.Builder.setMetadataExtras(
+    positionMs: Long? = null,
+    videoScale: Float? = null,
+    playbackSpeed: Float? = null,
+    audioTrackIndex: Int? = null,
+    subtitleTrackIndex: Int? = null,
+    subtitleDelayMilliseconds: Long? = null,
+    subtitleSpeed: Float? = null,
+    videoWidth: Int? = null,
+    videoHeight: Int? = null,
+    videoRotation: Int? = null,
+    hasRenderedFirstFrame: Boolean? = null,
+    isApproximateSeekEnabled: Boolean? = null,
+    isVideoEffectsAvailable: Boolean? = null,
+    requestHeaders: Map<String, String> = emptyMap(),
+    remoteServerId: Long? = null,
+    remoteFilePath: String? = null,
+    remoteProtocol: String? = null,
+    localParentPath: String? = null,
+    remoteDirectoryPath: String? = null,
+): MediaMetadata.Builder = setExtras(
+    Bundle().setExtras(
+        positionMs = positionMs,
+        videoScale = videoScale,
+        playbackSpeed = playbackSpeed,
+        audioTrackIndex = audioTrackIndex,
+        subtitleTrackIndex = subtitleTrackIndex,
+        subtitleDelayMilliseconds = subtitleDelayMilliseconds,
+        subtitleSpeed = subtitleSpeed,
+        videoWidth = videoWidth,
+        videoHeight = videoHeight,
+        videoRotation = videoRotation,
+        hasRenderedFirstFrame = hasRenderedFirstFrame,
+        isApproximateSeekEnabled = isApproximateSeekEnabled,
+        isVideoEffectsAvailable = isVideoEffectsAvailable,
+        remoteServerId = remoteServerId,
+        remoteFilePath = remoteFilePath,
+        remoteProtocol = remoteProtocol,
+        localParentPath = localParentPath,
+        remoteDirectoryPath = remoteDirectoryPath,
+    ).apply {
+        requestHeaders.forEach { (key, value) ->
+            putString("$MEDIA_METADATA_REQUEST_HEADERS_PREFIX$key", value)
+        }
+    },
+)
+
+val MediaMetadata.positionMs: Long?
+    get() = extras?.run {
+        getLong(MEDIA_METADATA_POSITION_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_POSITION_KEY) }
+    }
+
+val MediaMetadata.playbackSpeed: Float?
+    get() = extras?.run {
+        getFloat(MEDIA_METADATA_PLAYBACK_SPEED_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_PLAYBACK_SPEED_KEY) }
+    }
+
+val MediaMetadata.audioTrackIndex: Int?
+    get() = extras?.run {
+        getInt(MEDIA_METADATA_AUDIO_TRACK_INDEX_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_AUDIO_TRACK_INDEX_KEY) }
+    }
+
+val MediaMetadata.subtitleTrackIndex: Int?
+    get() = extras?.run {
+        getInt(MEDIA_METADATA_SUBTITLE_TRACK_INDEX_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_SUBTITLE_TRACK_INDEX_KEY) }
+    }
+
+val MediaMetadata.videoZoom: Float?
+    get() = extras?.run {
+        getFloat(MEDIA_METADATA_VIDEO_ZOOM_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_VIDEO_ZOOM_KEY) }
+    }
+
+val MediaMetadata.subtitleDelayMilliseconds: Long?
+    get() = extras?.run {
+        getLong(MEDIA_METADATA_SUBTITLE_DELAY_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_SUBTITLE_DELAY_KEY) }
+    }
+
+val MediaMetadata.subtitleSpeed: Float?
+    get() = extras?.run {
+        getFloat(MEDIA_METADATA_SUBTITLE_SPEED_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_SUBTITLE_SPEED_KEY) }
+    }
+
+val MediaMetadata.videoWidth: Int?
+    get() = extras?.run {
+        getInt(MEDIA_METADATA_VIDEO_WIDTH_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_VIDEO_WIDTH_KEY) }
+    }
+
+val MediaMetadata.videoHeight: Int?
+    get() = extras?.run {
+        getInt(MEDIA_METADATA_VIDEO_HEIGHT_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_VIDEO_HEIGHT_KEY) }
+    }
+
+val MediaMetadata.videoRotation: Int?
+    get() = extras?.run {
+        getInt(MEDIA_METADATA_VIDEO_ROTATION_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_VIDEO_ROTATION_KEY) }
+    }
+
+val MediaMetadata.hasRenderedFirstFrame: Boolean
+    get() = extras?.getBoolean(MEDIA_METADATA_HAS_RENDERED_FIRST_FRAME_KEY, false) == true
+
+val MediaMetadata.isApproximateSeekEnabled: Boolean
+    get() = extras?.getBoolean(MEDIA_METADATA_APPROXIMATE_SEEK_ENABLED_KEY, false) == true
+
+val MediaMetadata.isVideoEffectsAvailable: Boolean
+    get() = extras?.getBoolean(MEDIA_METADATA_VIDEO_EFFECTS_AVAILABLE_KEY, true) != false
+
+val MediaMetadata.requestHeaders: Map<String, String>
+    get() = extras?.keySet()
+        ?.filter { it.startsWith(MEDIA_METADATA_REQUEST_HEADERS_PREFIX) }
+        ?.associate { key ->
+            key.removePrefix(MEDIA_METADATA_REQUEST_HEADERS_PREFIX) to extras?.getString(key).orEmpty()
+        }
+        ?.filterValues { it.isNotEmpty() }
+        ?: emptyMap()
+
+val MediaMetadata.remoteServerId: Long?
+    get() = extras?.run {
+        getLong(MEDIA_METADATA_REMOTE_SERVER_ID_KEY)
+            .takeIf { containsKey(MEDIA_METADATA_REMOTE_SERVER_ID_KEY) }
+    }
+
+val MediaMetadata.remoteFilePath: String?
+    get() = extras?.getString(MEDIA_METADATA_REMOTE_FILE_PATH_KEY)
+        ?.takeIf(String::isNotBlank)
+
+val MediaMetadata.remoteProtocol: String?
+    get() = extras?.getString(MEDIA_METADATA_REMOTE_PROTOCOL_KEY)
+        ?.takeIf(String::isNotBlank)
+
+val MediaMetadata.localParentPath: String?
+    get() = extras?.getString(MEDIA_METADATA_LOCAL_PARENT_PATH_KEY)
+        ?.takeIf(String::isNotBlank)
+
+val MediaMetadata.remoteDirectoryPath: String?
+    get() = extras?.getString(MEDIA_METADATA_REMOTE_DIRECTORY_PATH_KEY)
+        ?.takeIf(String::isNotBlank)
+
+fun MediaItem.copy(
+    positionMs: Long? = this.mediaMetadata.positionMs,
+    durationMs: Long? = this.mediaMetadata.durationMs,
+    videoZoom: Float? = this.mediaMetadata.videoZoom,
+    playbackSpeed: Float? = this.mediaMetadata.playbackSpeed,
+    audioTrackIndex: Int? = this.mediaMetadata.audioTrackIndex,
+    subtitleTrackIndex: Int? = this.mediaMetadata.subtitleTrackIndex,
+    subtitleDelayMilliseconds: Long? = this.mediaMetadata.subtitleDelayMilliseconds,
+    subtitleSpeed: Float? = this.mediaMetadata.subtitleSpeed,
+    videoWidth: Int? = this.mediaMetadata.videoWidth,
+    videoHeight: Int? = this.mediaMetadata.videoHeight,
+    videoRotation: Int? = this.mediaMetadata.videoRotation,
+    hasRenderedFirstFrame: Boolean? = this.mediaMetadata.hasRenderedFirstFrame,
+    isApproximateSeekEnabled: Boolean? = this.mediaMetadata.isApproximateSeekEnabled,
+    isVideoEffectsAvailable: Boolean? = this.mediaMetadata.isVideoEffectsAvailable,
+    requestHeaders: Map<String, String> = this.mediaMetadata.requestHeaders,
+    remoteServerId: Long? = this.mediaMetadata.remoteServerId,
+    remoteFilePath: String? = this.mediaMetadata.remoteFilePath,
+    remoteProtocol: String? = this.mediaMetadata.remoteProtocol,
+    localParentPath: String? = this.mediaMetadata.localParentPath,
+    remoteDirectoryPath: String? = this.mediaMetadata.remoteDirectoryPath,
+): MediaItem = buildUpon().setMediaMetadata(
+    mediaMetadata.buildUpon()
+        .setMetadataExtras(
+            positionMs = positionMs,
+            videoScale = videoZoom,
+            playbackSpeed = playbackSpeed,
+            audioTrackIndex = audioTrackIndex,
+            subtitleTrackIndex = subtitleTrackIndex,
+            subtitleDelayMilliseconds = subtitleDelayMilliseconds,
+            subtitleSpeed = subtitleSpeed,
+            videoWidth = videoWidth,
+            videoHeight = videoHeight,
+            videoRotation = videoRotation,
+            hasRenderedFirstFrame = hasRenderedFirstFrame,
+            isApproximateSeekEnabled = isApproximateSeekEnabled,
+            isVideoEffectsAvailable = isVideoEffectsAvailable,
+            remoteServerId = remoteServerId,
+            remoteFilePath = remoteFilePath,
+            remoteProtocol = remoteProtocol,
+            localParentPath = localParentPath,
+            remoteDirectoryPath = remoteDirectoryPath,
+        ).apply {
+            requestHeaders.forEach { (key, value) ->
+                // Builder doesn't have putString, we must use setExtras with a Bundle
+                // This is already handled by setMetadataExtras above
+            }
+        }.build(),
+).build()
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Modifier.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Modifier.kt
new file mode 100644
index 000000000..bc5cdf306
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Modifier.kt
@@ -0,0 +1,15 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+
+@Composable
+fun Modifier.noRippleClickable(isEnabled: Boolean = true, onClick: () -> Unit): Modifier = clickable(
+    interactionSource = remember { MutableInteractionSource() },
+    indication = null,
+    enabled = isEnabled,
+    onClick = onClick,
+)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/OpenDocumentWithInitialUri.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/OpenDocumentWithInitialUri.kt
new file mode 100644
index 000000000..a21bc564b
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/OpenDocumentWithInitialUri.kt
@@ -0,0 +1,27 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.provider.DocumentsContract
+import androidx.activity.result.contract.ActivityResultContract
+
+class OpenDocumentWithInitialUri : ActivityResultContract<OpenDocumentWithInitialUri.Input, Uri?>() {
+
+    data class Input(
+        val mimeTypes: Array<String>,
+        val initialUri: Uri? = null,
+    )
+
+    override fun createIntent(context: Context, input: Input): Intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
+        addCategory(Intent.CATEGORY_OPENABLE)
+        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+        addFlags(Intent.FLAG_GRANT_PREFIX_URI_PERMISSION)
+        type = if (input.mimeTypes.size == 1) input.mimeTypes.first() else "*/*"
+        putExtra(Intent.EXTRA_MIME_TYPES, input.mimeTypes)
+        putExtra(Intent.EXTRA_ALLOW_MULTIPLE, false)
+        input.initialUri?.let { putExtra(DocumentsContract.EXTRA_INITIAL_URI, it) }
+    }
+
+    override fun parseResult(resultCode: Int, intent: Intent?): Uri? = intent?.data
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Player.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Player.kt
new file mode 100644
index 000000000..ac31e04c9
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Player.kt
@@ -0,0 +1,137 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import androidx.annotation.OptIn
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.TrackSelectionOverride
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.session.MediaController
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.preciseSeekTo
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.setMediaControllerIsScrubbingModeEnabled
+
+fun Player.switchTrack(trackType: @C.TrackType Int, trackIndex: Int) {
+    val trackTypeText = when (trackType) {
+        C.TRACK_TYPE_AUDIO -> "audio"
+        C.TRACK_TYPE_TEXT -> "subtitle"
+        else -> throw IllegalArgumentException("Invalid track type: $trackType")
+    }
+
+    if (trackIndex < 0) {
+        Logger.debug("Player", "Disabling $trackTypeText")
+        trackSelectionParameters = trackSelectionParameters
+            .buildUpon()
+            .setTrackTypeDisabled(trackType, true)
+            .build()
+    } else {
+        val tracks = currentTracks.groups.filter { it.type == trackType }
+
+        if (tracks.isEmpty() || trackIndex >= tracks.size) {
+            Logger.error("Player", "Operation failed: Invalid track index: $trackIndex")
+            return
+        }
+
+        Logger.debug("Player", "Setting $trackTypeText track: $trackIndex")
+        val selectedGroup = tracks[trackIndex]
+        val format = selectedGroup.mediaTrackGroup.getFormat(0)
+        Logger.debug(
+            "Player",
+            "Track format: mime=${format.sampleMimeType}, label=${format.label}, id=${format.id}",
+        )
+        val trackSelectionOverride = TrackSelectionOverride(tracks[trackIndex].mediaTrackGroup, 0)
+
+
+        trackSelectionParameters = trackSelectionParameters
+            .buildUpon()
+            .setTrackTypeDisabled(trackType, false)
+            .setOverrideForType(trackSelectionOverride)
+            .build()
+    }
+}
+
+@UnstableApi
+fun Player.getManuallySelectedTrackIndex(trackType: @C.TrackType Int): Int? {
+    val isDisabled = trackSelectionParameters.disabledTrackTypes.contains(trackType)
+    if (isDisabled) return -1
+
+    val trackOverrides = trackSelectionParameters.overrides.values.map { it.mediaTrackGroup }
+    val trackOverride = trackOverrides.firstOrNull { it.type == trackType } ?: return null
+    val tracks = currentTracks.groups.filter { it.type == trackType }
+
+    return tracks.indexOfFirst { it.mediaTrackGroup == trackOverride }.takeIf { it != -1 }
+}
+
+fun Player.addAdditionalSubtitleConfiguration(subtitle: MediaItem.SubtitleConfiguration) {
+    val currentMediaItemLocal = currentMediaItem ?: return
+    val existingSubConfigurations = currentMediaItemLocal.localConfiguration?.subtitleConfigurations ?: emptyList()
+
+    if (existingSubConfigurations.any { it.id == subtitle.id }) {
+        return
+    }
+
+    val updateMediaItem = currentMediaItemLocal
+        .buildUpon()
+        .setSubtitleConfigurations(existingSubConfigurations + listOf(subtitle))
+        .build()
+
+    val index = currentMediaItemIndex
+    addMediaItem(index + 1, updateMediaItem)
+    seekToDefaultPosition(index + 1)
+    removeMediaItem(index)
+}
+
+fun Player.availableDurationMs(): Long {
+    val playerDuration = duration
+    if (playerDuration != C.TIME_UNSET && playerDuration > 0L) {
+        return playerDuration
+    }
+
+    // currentMediaItem 的 metadata 和 player 顶层 metadata 可能不同步
+    return currentMediaItem?.mediaMetadata?.durationMs?.takeIf { it > 0L }
+        ?: mediaMetadata.durationMs?.takeIf { it > 0L }
+        ?: C.TIME_UNSET
+}
+
+fun Player.canSeekCurrentMediaItem(): Boolean {
+    if (availableDurationMs() == C.TIME_UNSET) return false
+
+    return when (this) {
+        is MediaController -> {
+            isCommandAvailable(Player.COMMAND_SEEK_IN_CURRENT_MEDIA_ITEM) ||
+                currentMediaItem?.mediaMetadata?.isApproximateSeekEnabled == true
+        }
+
+        else -> true
+    }
+}
+
+fun Player.seekToRequestedPosition(positionMs: Long) {
+    val duration = availableDurationMs()
+    if (duration == C.TIME_UNSET) return
+
+    val targetPosition = positionMs.coerceIn(0L, duration)
+    if (this is MediaController) {
+        // approximate source 的 seekTo 会从头顺序读取，必须走 preciseSeekTo 触发 source 升级
+        if (currentMediaItem?.mediaMetadata?.isApproximateSeekEnabled == true) {
+            preciseSeekTo(targetPosition)
+            return
+        }
+    }
+
+    seekTo(targetPosition)
+}
+
+fun Player.seekByRequestedOffset(offsetMs: Long) {
+    val currentPosition = currentPosition.takeIf { it != C.TIME_UNSET } ?: 0L
+    seekToRequestedPosition(currentPosition + offsetMs)
+}
+
+@OptIn(UnstableApi::class)
+fun Player.setIsScrubbingModeEnabled(isEnabled: Boolean) {
+    when (this) {
+        is MediaController -> this.setMediaControllerIsScrubbingModeEnabled(isEnabled)
+        is ExoPlayer -> this.isScrubbingModeEnabled = isEnabled
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/PlayerView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/PlayerView.kt
new file mode 100644
index 000000000..4630cbc39
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/PlayerView.kt
@@ -0,0 +1,14 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.PlayerView
+
+@UnstableApi
+fun PlayerView.togglePlayPause() {
+    this.controllerAutoShow = this.isControllerFullyVisible
+    if (this.player?.isPlaying == true) {
+        this.player?.pause()
+    } else {
+        this.player?.play()
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/PointerInputScope.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/PointerInputScope.kt
new file mode 100644
index 000000000..e1fc96ccb
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/PointerInputScope.kt
@@ -0,0 +1,184 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.gestures.awaitHorizontalTouchSlopOrCancellation
+import androidx.compose.foundation.gestures.awaitVerticalTouchSlopOrCancellation
+import androidx.compose.foundation.gestures.calculateCentroid
+import androidx.compose.foundation.gestures.calculateCentroidSize
+import androidx.compose.foundation.gestures.calculatePan
+import androidx.compose.foundation.gestures.calculateRotation
+import androidx.compose.foundation.gestures.calculateZoom
+import androidx.compose.foundation.gestures.horizontalDrag
+import androidx.compose.foundation.gestures.verticalDrag
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.PointerInputChange
+import androidx.compose.ui.input.pointer.PointerInputScope
+import androidx.compose.ui.input.pointer.positionChange
+import androidx.compose.ui.input.pointer.positionChanged
+import kotlin.math.abs
+
+suspend fun PointerInputScope.detectCustomTransformGestures(
+    isPanZoomLocked: Boolean = false,
+    pass: PointerEventPass = PointerEventPass.Main,
+    pointCount: Int = 2,
+    onGestureStart: (PointerInputChange) -> Unit = {},
+    onGesture: (
+        centroid: Offset,
+        pan: Offset,
+        zoom: Float,
+        rotation: Float,
+    ) -> Unit,
+    onGestureEnd: (PointerInputChange) -> Unit = {},
+) {
+    awaitEachGesture {
+        var rotation = 0f
+        var zoom = 1f
+        var pan = Offset.Zero
+        var hasPassedTouchSlop = false
+        val touchSlop = viewConfiguration.touchSlop
+        var isLockedToPanZoom = false
+        var hasGestureStarted = false
+
+        val down: PointerInputChange = awaitFirstDown(
+            requireUnconsumed = false,
+            pass = pass,
+        )
+
+        var pointer = down
+        var pointerId = down.id
+
+        do {
+            val event = awaitPointerEvent(pass = pass)
+
+            val currentPointerCount = event.changes.count { it.pressed }
+
+            val isCanceled = event.changes.any { it.isConsumed } || currentPointerCount != pointCount
+
+            if (!isCanceled) {
+                if (!hasGestureStarted) {
+                    hasGestureStarted = true
+                    onGestureStart(pointer)
+                }
+
+                val pointerInputChange = event.changes.firstOrNull { it.id == pointerId }
+                    ?: event.changes.first()
+
+                pointerId = pointerInputChange.id
+                pointer = pointerInputChange
+
+                val zoomChange = event.calculateZoom()
+                val rotationChange = event.calculateRotation()
+                val panChange = event.calculatePan()
+
+                if (!hasPassedTouchSlop) {
+                    zoom *= zoomChange
+                    rotation += rotationChange
+                    pan += panChange
+
+                    val centroidSize = event.calculateCentroidSize(useCurrent = false)
+                    val zoomMotion = abs(1 - zoom) * centroidSize
+                    val rotationMotion = abs(
+                        rotation * kotlin.math.PI.toFloat() * centroidSize / 180f,
+                    )
+                    val panMotion = pan.getDistance()
+
+                    if (zoomMotion > touchSlop ||
+                        rotationMotion > touchSlop ||
+                        panMotion > touchSlop
+                    ) {
+                        hasPassedTouchSlop = true
+                        isLockedToPanZoom = isPanZoomLocked && rotationMotion < touchSlop
+                    }
+                }
+
+                if (hasPassedTouchSlop) {
+                    val centroid = event.calculateCentroid(useCurrent = false)
+                    val effectiveRotation = if (isLockedToPanZoom) 0f else rotationChange
+                    if (effectiveRotation != 0f ||
+                        zoomChange != 1f ||
+                        panChange != Offset.Zero
+                    ) {
+                        onGesture(
+                            centroid,
+                            panChange,
+                            zoomChange,
+                            effectiveRotation,
+                        )
+                    }
+
+                    event.changes.forEach {
+                        if (it.positionChanged()) {
+                            it.consume()
+                        }
+                    }
+                }
+            }
+        } while (!isCanceled && event.changes.any { it.pressed })
+
+        if (hasGestureStarted) {
+            onGestureEnd(pointer)
+        }
+    }
+}
+
+suspend fun PointerInputScope.detectCustomHorizontalDragGestures(
+    onDragStart: (Offset) -> Unit = {},
+    onDragEnd: () -> Unit = {},
+    onDragCancel: () -> Unit = {},
+    onHorizontalDrag: (change: PointerInputChange, dragAmount: Float) -> Unit,
+) {
+    awaitEachGesture {
+        val down = awaitFirstDown(requireUnconsumed = false)
+        var overSlop = 0f
+        val drag = awaitHorizontalTouchSlopOrCancellation(down.id) { change, over ->
+            change.consume()
+            overSlop = over
+        }
+        if (drag != null && currentEvent.changes.count { it.pressed } == 1) {
+            onDragStart.invoke(drag.position)
+            onHorizontalDrag(drag, overSlop)
+            if (
+                horizontalDrag(drag.id) {
+                    onHorizontalDrag(it, it.positionChange().x)
+                    it.consume()
+                }
+            ) {
+                onDragEnd()
+            } else {
+                onDragCancel()
+            }
+        }
+    }
+}
+
+suspend fun PointerInputScope.detectCustomVerticalDragGestures(
+    onDragStart: (Offset) -> Unit = {},
+    onDragEnd: () -> Unit = {},
+    onDragCancel: () -> Unit = {},
+    onVerticalDrag: (change: PointerInputChange, dragAmount: Float) -> Unit,
+) {
+    awaitEachGesture {
+        val down = awaitFirstDown(requireUnconsumed = false)
+        var overSlop = 0f
+        val drag = awaitVerticalTouchSlopOrCancellation(down.id) { change, over ->
+            change.consume()
+            overSlop = over
+        }
+        if (drag != null && currentEvent.changes.count { it.pressed } == 1) {
+            onDragStart.invoke(drag.position)
+            onVerticalDrag.invoke(drag, overSlop)
+            if (
+                verticalDrag(drag.id) {
+                    onVerticalDrag(it, it.positionChange().y)
+                    it.consume()
+                }
+            ) {
+                onDragEnd()
+            } else {
+                onDragCancel()
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/ScreenOrientation.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/ScreenOrientation.kt
new file mode 100644
index 000000000..2f5cd6ff0
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/ScreenOrientation.kt
@@ -0,0 +1,19 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import android.content.pm.ActivityInfo
+import app.gyrolet.mpvrx.exoplayer.core.model.LastPlayerScreenOrientation
+import app.gyrolet.mpvrx.exoplayer.core.model.ScreenOrientation
+
+fun LastPlayerScreenOrientation.toActivityOrientation(): Int = when (this) {
+    LastPlayerScreenOrientation.PORTRAIT -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
+    LastPlayerScreenOrientation.LANDSCAPE -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+}
+
+fun ScreenOrientation.toActivityOrientation(videoOrientation: Int? = null): Int = when (this) {
+    ScreenOrientation.AUTOMATIC -> ActivityInfo.SCREEN_ORIENTATION_SENSOR
+    ScreenOrientation.LANDSCAPE -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+    ScreenOrientation.LANDSCAPE_REVERSE -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
+    ScreenOrientation.LANDSCAPE_AUTO -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+    ScreenOrientation.PORTRAIT -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
+    ScreenOrientation.VIDEO_ORIENTATION -> videoOrientation ?: ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/SuspendActivityResultLauncher.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/SuspendActivityResultLauncher.kt
new file mode 100644
index 000000000..3a3ed55f3
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/SuspendActivityResultLauncher.kt
@@ -0,0 +1,36 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import androidx.activity.ComponentActivity
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.contract.ActivityResultContract
+import kotlin.coroutines.resume
+import kotlinx.coroutines.suspendCancellableCoroutine
+
+class SuspendActivityResultLauncher<I, O>(
+    activity: ComponentActivity,
+    contract: ActivityResultContract<I, O>,
+) {
+    private var activityResultCallback: ((result: O) -> Unit)? = null
+    private var activityResultLauncher: ActivityResultLauncher<I> = activity.registerForActivityResult(
+        contract = contract,
+        callback = { result -> activityResultCallback?.invoke(result) },
+    )
+
+    val isAwaitingResult: Boolean
+        get() = activityResultCallback != null
+
+    suspend fun launch(input: I): O = suspendCancellableCoroutine { continuation ->
+        activityResultCallback = {
+            continuation.resume(it)
+            activityResultCallback = null
+        }
+        activityResultLauncher.launch(input)
+        continuation.invokeOnCancellation {
+            activityResultCallback = null
+        }
+    }
+}
+
+fun <I, O> ComponentActivity.registerForSuspendActivityResult(
+    contract: ActivityResultContract<I, O>,
+): SuspendActivityResultLauncher<I, O> = SuspendActivityResultLauncher(this, contract)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/TrackGroup.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/TrackGroup.kt
new file mode 100644
index 000000000..523be0643
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/TrackGroup.kt
@@ -0,0 +1,30 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import androidx.media3.common.C
+import androidx.media3.common.TrackGroup
+import androidx.media3.common.util.UnstableApi
+import java.util.Locale
+
+@UnstableApi
+fun TrackGroup.getName(trackType: @C.TrackType Int, index: Int): String {
+    val format = this.getFormat(0)
+    val language = format.language
+    val label = format.label
+    return buildString {
+        if (label != null) {
+            append(label)
+        }
+        if (isEmpty()) {
+            if (trackType == C.TRACK_TYPE_TEXT) {
+                append("Subtitle Track #${index + 1}")
+            } else {
+                append("Audio Track #${index + 1}")
+            }
+        }
+
+        if (language != null && language != "und") {
+            append(" - ")
+            append(Locale.forLanguageTag(language).displayLanguage)
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Uri.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Uri.kt
new file mode 100644
index 000000000..413e72043
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/Uri.kt
@@ -0,0 +1,279 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import android.content.ContentResolver
+import android.content.Context
+import android.net.Uri
+import android.os.Bundle
+import androidx.core.os.BundleCompat
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MimeTypes
+import java.io.File
+import java.nio.charset.Charset
+import java.nio.charset.StandardCharsets
+import java.util.Locale
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.convertToUTF8
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.getFilenameFromUri
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.subtitleCacheDir
+
+fun Uri.getSubtitleMime(displayName: String? = null): String {
+    val name = displayName ?: path ?: ""
+    return when {
+        name.endsWith(".ssa", ignoreCase = true) ||
+            name.endsWith(".ass", ignoreCase = true) -> MimeTypes.TEXT_SSA
+        name.endsWith(".vtt", ignoreCase = true) -> MimeTypes.TEXT_VTT
+        name.endsWith(".ttml", ignoreCase = true) ||
+            name.endsWith(".xml", ignoreCase = true) ||
+            name.endsWith(".dfxp", ignoreCase = true) -> MimeTypes.APPLICATION_TTML
+        else -> MimeTypes.APPLICATION_SUBRIP
+    }
+}
+
+val Uri.isSchemaContent: Boolean
+    get() = ContentResolver.SCHEME_CONTENT.equals(scheme, ignoreCase = true)
+
+suspend fun Context.uriToSubtitleConfiguration(
+    uri: Uri,
+    subtitleEncoding: String = "",
+    isSelected: Boolean = false,
+): MediaItem.SubtitleConfiguration {
+    val charset = if (subtitleEncoding.isNotEmpty() && Charset.isSupported(subtitleEncoding)) {
+        Charset.forName(subtitleEncoding)
+    } else {
+        null
+    }
+    val label = getFilenameFromUri(uri)
+    val mimeType = uri.getSubtitleMime(displayName = label)
+    val utf8ConvertedUri = convertToUTF8(uri = uri, charset = charset)
+    val subtitleUri = normalizeAssFonts(uri = utf8ConvertedUri, label = label, mimeType = mimeType)
+    return MediaItem.SubtitleConfiguration.Builder(subtitleUri).apply {
+        setId(uri.toString())
+        setMimeType(mimeType)
+        setLabel(label)
+        if (isSelected) setSelectionFlags(C.SELECTION_FLAG_DEFAULT)
+    }.build()
+}
+
+private suspend fun Context.normalizeAssFonts(
+    uri: Uri,
+    label: String,
+    mimeType: String,
+): Uri {
+    if (mimeType != MimeTypes.TEXT_SSA) return uri
+
+    return withContext(Dispatchers.IO) {
+        try {
+            if (uri.scheme?.let { it in NETWORK_URI_SCHEMES } == true) return@withContext uri
+            val sourceText = contentResolver.openInputStream(uri)?.use { inputStream ->
+                inputStream.reader(StandardCharsets.UTF_8).readText()
+            } ?: return@withContext uri
+            val normalizedText = sourceText.normalizeAssSubtitleText()
+            if (normalizedText == sourceText) return@withContext uri
+
+            val file = File(subtitleCacheDir, normalizedAssFontFileName(label = label, uri = uri))
+            file.writeText(normalizedText, StandardCharsets.UTF_8)
+            Uri.fromFile(file)
+        } catch (exception: Exception) {
+            Logger.error(SUBTITLE_CONFIG_TAG, "Failed to normalize ASS subtitle fonts", exception)
+            uri
+        }
+    }
+}
+
+internal fun String.normalizeAssSubtitleText(): String {
+    val lineSeparator = detectLineSeparator()
+    var section = AssSection.Other
+    var styleFontNameIndex: Int? = null
+    var eventTextIndex: Int? = null
+    var hasChanges = false
+    val normalizedLines = lineSequence().map { line ->
+        val trimmedLine = line.trim()
+        if (trimmedLine.startsWith("[") && trimmedLine.endsWith("]")) {
+            section = trimmedLine.assSection()
+            styleFontNameIndex = null
+            eventTextIndex = null
+            return@map line
+        }
+
+        val normalizedLine = when {
+            section == AssSection.Style && trimmedLine.startsWith("Format:", ignoreCase = true) -> {
+                styleFontNameIndex = trimmedLine.assFormatFieldIndex("Fontname")
+                line
+            }
+            section == AssSection.Style && trimmedLine.startsWith("Style:", ignoreCase = true) -> {
+                styleFontNameIndex?.let(line::normalizeAssStyleFont) ?: line
+            }
+            section == AssSection.Event && trimmedLine.startsWith("Format:", ignoreCase = true) -> {
+                eventTextIndex = trimmedLine.assFormatFieldIndex("Text")
+                line
+            }
+            section == AssSection.Event && isAssEventLine(trimmedLine) -> {
+                eventTextIndex?.let(line::normalizeAssEventText) ?: line
+            }
+            else -> line
+        }
+        if (normalizedLine != line) hasChanges = true
+        normalizedLine
+    }.toList()
+
+    if (!hasChanges) return this
+
+    val normalizedText = normalizedLines.joinToString(separator = lineSeparator)
+    return if (endsWith("\n") || endsWith("\r")) normalizedText + lineSeparator else normalizedText
+}
+
+private fun String.assSection(): AssSection = when (lowercase(Locale.US)) {
+    in ASS_STYLE_SECTION_HEADERS -> AssSection.Style
+    "[events]" -> AssSection.Event
+    else -> AssSection.Other
+}
+
+private fun String.assFormatFieldIndex(name: String): Int? = substringAfter(':')
+    .split(',')
+    .indexOfFirst { field -> field.trim().equals(name, ignoreCase = true) }
+    .takeIf { index -> index >= 0 }
+
+private fun String.normalizeAssStyleFont(fontNameIndex: Int): String {
+    val headerEndIndex = indexOf(':')
+    if (headerEndIndex < 0) return this
+
+    val prefix = substring(0, headerEndIndex + 1)
+    val fields = substring(headerEndIndex + 1).split(',').toMutableList()
+    if (fontNameIndex !in fields.indices) return this
+
+    val fontField = fields[fontNameIndex]
+    val fontName = fontField.trim().trim('"')
+    if (fontName.lowercase(Locale.US) !in ASS_FONT_NAMES_REQUIRING_FALLBACK) return this
+
+    val leadingWhitespace = fontField.takeWhile(Char::isWhitespace)
+    val trailingWhitespace = fontField.takeLastWhile(Char::isWhitespace)
+    fields[fontNameIndex] = leadingWhitespace + ASS_ANDROID_FALLBACK_FONT + trailingWhitespace
+    return prefix + fields.joinToString(",")
+}
+
+private fun String.normalizeAssEventText(textIndex: Int): String {
+    val headerEndIndex = indexOf(':')
+    if (headerEndIndex < 0) return this
+
+    val prefix = substring(0, headerEndIndex + 1)
+    return prefix + substring(headerEndIndex + 1).normalizeAssDialogueFields(textIndex)
+}
+
+internal fun String.normalizeAssDialogueFields(textIndex: Int): String {
+    val fields = split(',', limit = textIndex + 1).toMutableList()
+    if (textIndex !in fields.indices) return this
+
+    fields[textIndex] = fields[textIndex].normalizeAssDialogueText()
+    return fields.joinToString(",")
+}
+
+internal fun String.normalizeAssDialogueText(): String = normalizeAssInlineFonts()
+    .widenLatinSpaces()
+
+private fun String.normalizeAssInlineFonts(): String = ASS_INLINE_FONT_REGEX.replace(this) { match ->
+    val fontName = match.groupValues[1].trim()
+    if (fontName.lowercase(Locale.US) in ASS_FONT_NAMES_REQUIRING_FALLBACK) {
+        "\\fn$ASS_ANDROID_FALLBACK_FONT"
+    } else {
+        match.value
+    }
+}
+
+private fun String.widenLatinSpaces(): String = buildString(length) {
+    var isInOverrideBlock = false
+    for (index in this@widenLatinSpaces.indices) {
+        val char = this@widenLatinSpaces[index]
+        when (char) {
+            '{' -> isInOverrideBlock = true
+            '}' -> isInOverrideBlock = false
+        }
+        if (char == ' ' && !isInOverrideBlock && hasLatinNeighbor(index)) {
+            append(' ')
+            append(' ')
+        } else {
+            append(char)
+        }
+    }
+}
+
+private fun String.hasLatinNeighbor(index: Int): Boolean = previousVisibleChar(index)?.isLatinLetterOrDigit() == true &&
+    nextVisibleChar(index)?.isLatinLetterOrDigit() == true
+
+private fun String.previousVisibleChar(index: Int): Char? {
+    var currentIndex = index - 1
+    while (currentIndex >= 0 && this[currentIndex].isWhitespace()) currentIndex--
+    return getOrNull(currentIndex)
+}
+
+private fun String.nextVisibleChar(index: Int): Char? {
+    var currentIndex = index + 1
+    while (currentIndex < length && this[currentIndex].isWhitespace()) currentIndex++
+    return getOrNull(currentIndex)
+}
+
+private fun Char.isLatinLetterOrDigit(): Boolean = this in 'A'..'Z' || this in 'a'..'z' || this in '0'..'9'
+
+private fun isAssEventLine(line: String): Boolean = line.startsWith("Dialogue:", ignoreCase = true) ||
+    line.startsWith("Comment:", ignoreCase = true)
+
+private fun String.detectLineSeparator(): String = when {
+    contains("\r\n") -> "\r\n"
+    contains("\r") -> "\r"
+    else -> "\n"
+}
+
+private fun normalizedAssFontFileName(label: String, uri: Uri): String {
+    val baseName = label.ifBlank { "subtitle" }.substringBeforeLast('.', missingDelimiterValue = label.ifBlank { "subtitle" })
+    val extension = label.substringAfterLast('.', missingDelimiterValue = "ass")
+    val cacheKey = uri.toString().hashCode().toUInt().toString(radix = 16)
+    return "$baseName-$cacheKey.ass-font.$extension"
+}
+
+fun Bundle.getParcelableUriArray(key: String): ArrayList<Uri>? = BundleCompat.getParcelableArrayList(this, key, Uri::class.java)
+
+private const val SUBTITLE_CONFIG_TAG = "SubtitleConfig"
+private const val ASS_ANDROID_FALLBACK_FONT = "Roboto"
+
+private enum class AssSection {
+    Style,
+    Event,
+    Other,
+}
+
+private val ASS_INLINE_FONT_REGEX = Regex("\\\\fn([^\\\\}]+)")
+
+private val NETWORK_URI_SCHEMES = setOf("http", "https", "ftp")
+
+private val ASS_STYLE_SECTION_HEADERS = setOf(
+    "[v4 styles]",
+    "[v4+ styles]",
+)
+
+private val ASS_FONT_NAMES_REQUIRING_FALLBACK = setOf(
+    "arial",
+    "calibri",
+    "cambria",
+    "candara",
+    "comic sans ms",
+    "consolas",
+    "courier new",
+    "georgia",
+    "helvetica",
+    "microsoft sans serif",
+    "ms sans serif",
+    "segoe ui",
+    "tahoma",
+    "times new roman",
+    "trebuchet ms",
+    "verdana",
+)
+
+suspend fun Context.getPath(uri: Uri): String? = withContext(Dispatchers.IO) {
+    if (uri.scheme == "file") {
+        return@withContext uri.path
+    }
+    return@withContext null
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/VideoContentScale.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/VideoContentScale.kt
new file mode 100644
index 000000000..9a791634e
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/VideoContentScale.kt
@@ -0,0 +1,27 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.layout.FixedScale
+import app.gyrolet.mpvrx.exoplayer.core.model.VideoContentScale
+import app.gyrolet.mpvrx.R
+
+fun VideoContentScale.nameRes(): Int = when (this) {
+    VideoContentScale.BEST_FIT -> R.string.best_fit
+    VideoContentScale.STRETCH -> R.string.stretch
+    VideoContentScale.CROP -> R.string.player_aspect_crop
+    VideoContentScale.HUNDRED_PERCENT -> R.string.hundred_percent
+}
+
+fun VideoContentScale.drawableRes(): Int = when (this) {
+    VideoContentScale.BEST_FIT -> R.drawable.ic_fit_screen
+    VideoContentScale.STRETCH -> R.drawable.ic_aspect_ratio
+    VideoContentScale.CROP -> R.drawable.ic_crop_landscape
+    VideoContentScale.HUNDRED_PERCENT -> R.drawable.ic_width_wide
+}
+
+fun VideoContentScale.toContentScale(): ContentScale = when (this) {
+    VideoContentScale.BEST_FIT -> ContentScale.Fit
+    VideoContentScale.STRETCH -> ContentScale.FillBounds
+    VideoContentScale.CROP -> ContentScale.Crop
+    VideoContentScale.HUNDRED_PERCENT -> FixedScale(1.0f)
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/VideoSize.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/VideoSize.kt
new file mode 100644
index 000000000..2659b6cab
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/extensions/VideoSize.kt
@@ -0,0 +1,7 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.extensions
+
+import androidx.media3.common.VideoSize
+
+
+val VideoSize.isPortrait: Boolean
+    get() = height >= width
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/input/PlayerKeyboardController.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/input/PlayerKeyboardController.kt
new file mode 100644
index 000000000..7ed7d1bb4
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/input/PlayerKeyboardController.kt
@@ -0,0 +1,145 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.input
+
+import android.view.KeyEvent
+
+class PlayerKeyboardController(
+    private val onSeekBackward: () -> Unit,
+    private val onSeekForward: () -> Unit,
+    private val onIncreaseVolume: () -> Unit,
+    private val onDecreaseVolume: () -> Unit,
+    private val onTogglePlayPause: () -> Unit,
+    private val onStartTemporarySpeed: () -> Boolean,
+    private val onStopTemporarySpeed: () -> Unit,
+) {
+
+    private var isLeftKeyPressed = false
+    private var isRightKeyPressed = false
+    private var isSpaceKeyPressed = false
+    private var hasSpaceLongPressStarted = false
+    private var isSpaceTemporarySpeedActive = false
+
+    fun handleKeyEvent(event: KeyEvent): Boolean = handleKeyEvent(
+        action = event.action,
+        keyCode = event.keyCode,
+        repeatCount = event.repeatCount,
+        isCanceled = event.isCanceled,
+    )
+
+    internal fun handleKeyEvent(
+        action: Int,
+        keyCode: Int,
+        repeatCount: Int,
+        isCanceled: Boolean = false,
+    ): Boolean = when (keyCode) {
+        KeyEvent.KEYCODE_DPAD_LEFT -> handleLeftKey(action = action, isCanceled = isCanceled)
+        KeyEvent.KEYCODE_DPAD_RIGHT -> handleRightKey(
+            action = action,
+            isCanceled = isCanceled,
+        )
+
+        KeyEvent.KEYCODE_DPAD_UP -> handleVolumeKey(action = action, onActionDown = onIncreaseVolume)
+        KeyEvent.KEYCODE_DPAD_DOWN -> handleVolumeKey(action = action, onActionDown = onDecreaseVolume)
+        KeyEvent.KEYCODE_ENTER,
+        KeyEvent.KEYCODE_NUMPAD_ENTER,
+        KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE,
+        KeyEvent.KEYCODE_DPAD_CENTER,
+        -> handleTogglePlaybackKey(action = action, isCanceled = isCanceled)
+        KeyEvent.KEYCODE_SPACE -> handleSpaceKey(
+            action = action,
+            repeatCount = repeatCount,
+            isCanceled = isCanceled,
+        )
+
+        else -> false
+    }
+
+    private fun handleLeftKey(action: Int, isCanceled: Boolean): Boolean = when (action) {
+        KeyEvent.ACTION_DOWN -> {
+            isLeftKeyPressed = true
+            true
+        }
+
+        KeyEvent.ACTION_UP -> {
+            val shouldSeekBackward = isLeftKeyPressed && !isCanceled
+            isLeftKeyPressed = false
+            if (shouldSeekBackward) {
+                onSeekBackward()
+            }
+            true
+        }
+
+        else -> false
+    }
+
+    private fun handleRightKey(action: Int, isCanceled: Boolean): Boolean = when (action) {
+        KeyEvent.ACTION_DOWN -> {
+            isRightKeyPressed = true
+            true
+        }
+
+        KeyEvent.ACTION_UP -> {
+            val shouldSeekForward = isRightKeyPressed && !isCanceled
+            isRightKeyPressed = false
+            if (shouldSeekForward) {
+                onSeekForward()
+            }
+            true
+        }
+
+        else -> false
+    }
+
+    private fun handleVolumeKey(action: Int, onActionDown: () -> Unit): Boolean = when (action) {
+        KeyEvent.ACTION_DOWN -> {
+            onActionDown()
+            true
+        }
+
+        KeyEvent.ACTION_UP -> true
+        else -> false
+    }
+
+    private fun handleSpaceKey(action: Int, repeatCount: Int, isCanceled: Boolean): Boolean = when (action) {
+        KeyEvent.ACTION_DOWN -> {
+            isSpaceKeyPressed = true
+            if (repeatCount > 0 && !hasSpaceLongPressStarted) {
+                val didStartTemporarySpeed = onStartTemporarySpeed()
+                hasSpaceLongPressStarted = didStartTemporarySpeed
+                isSpaceTemporarySpeedActive = didStartTemporarySpeed
+            }
+            true
+        }
+
+        KeyEvent.ACTION_UP -> {
+            val shouldTogglePlayback = isSpaceKeyPressed && !hasSpaceLongPressStarted && !isCanceled
+            if (isSpaceTemporarySpeedActive) {
+                onStopTemporarySpeed()
+            }
+            resetSpaceKeyState()
+            if (shouldTogglePlayback) {
+                onTogglePlayPause()
+            }
+            true
+        }
+
+        else -> false
+    }
+
+    private fun handleTogglePlaybackKey(action: Int, isCanceled: Boolean): Boolean = when (action) {
+        KeyEvent.ACTION_DOWN -> true
+        KeyEvent.ACTION_UP -> {
+            if (!isCanceled) {
+                onTogglePlayPause()
+            }
+            true
+        }
+
+        else -> false
+    }
+
+    private fun resetSpaceKeyState() {
+        isSpaceKeyPressed = false
+        hasSpaceLongPressStarted = false
+        isSpaceTemporarySpeedActive = false
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/model/Subtitle.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/model/Subtitle.kt
new file mode 100644
index 000000000..b7be19f17
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/model/Subtitle.kt
@@ -0,0 +1,9 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.model
+
+import android.net.Uri
+
+data class Subtitle(
+    val name: String?,
+    val uri: Uri,
+    val isSelected: Boolean,
+)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/CustomCommands.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/CustomCommands.kt
new file mode 100644
index 000000000..742efda9b
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/CustomCommands.kt
@@ -0,0 +1,181 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.service
+
+import android.net.Uri
+import android.os.Bundle
+import androidx.media3.session.MediaController
+import androidx.media3.session.SessionCommand
+import kotlinx.coroutines.guava.await
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+
+enum class CustomCommands(val customAction: String) {
+    ADD_SUBTITLE_TRACK(customAction = "ADD_SUBTITLE_TRACK"),
+    PRECISE_SEEK_TO(customAction = "PRECISE_SEEK_TO"),
+    SET_SKIP_SILENCE_ENABLED(customAction = "SET_SKIP_SILENCE_ENABLED"),
+    GET_SKIP_SILENCE_ENABLED(customAction = "GET_SKIP_SILENCE_ENABLED"),
+    SET_IS_SCRUBBING_MODE_ENABLED(customAction = "SET_IS_SCRUBBING_MODE_ENABLED"),
+    SET_PERSISTENT_PLAYBACK_SPEED(customAction = "SET_PERSISTENT_PLAYBACK_SPEED"),
+    SET_TRANSIENT_PLAYBACK_SPEED(customAction = "SET_TRANSIENT_PLAYBACK_SPEED"),
+    GET_SUBTITLE_DELAY(customAction = "GET_SUBTITLE_DELAY"),
+    SET_SUBTITLE_DELAY(customAction = "SET_SUBTITLE_DELAY"),
+    GET_SUBTITLE_SPEED(customAction = "GET_SUBTITLE_SPEED"),
+    SET_SUBTITLE_SPEED(customAction = "SET_SUBTITLE_SPEED"),
+    STOP_PLAYER_SESSION(customAction = "STOP_PLAYER_SESSION"),
+    IS_LOUDNESS_GAIN_SUPPORTED(customAction = "IS_LOUDNESS_GAIN_SUPPORTED"),
+    SET_LOUDNESS_GAIN(customAction = "SET_LOUDNESS_GAIN"),
+    GET_LOUDNESS_GAIN(customAction = "GET_LOUDNESS_GAIN"),
+    PREVIEW_VIDEO_FILTERS(customAction = "PREVIEW_VIDEO_FILTERS"),
+    SET_SCREEN_ASPECT_RATIO(customAction = "SET_SCREEN_ASPECT_RATIO"),
+    ;
+
+    val sessionCommand = SessionCommand(customAction, Bundle.EMPTY)
+
+    companion object {
+        fun fromSessionCommand(sessionCommand: SessionCommand): CustomCommands? = entries.find { it.customAction == sessionCommand.customAction }
+
+        fun asSessionCommands(): List<SessionCommand> = entries.map { it.sessionCommand }
+
+        const val SUBTITLE_TRACK_URI_KEY = "subtitle_track_uri"
+        const val SEEK_POSITION_MS_KEY = "seek_position_ms"
+        const val SKIP_SILENCE_ENABLED_KEY = "skip_silence_enabled"
+        const val IS_SCRUBBING_MODE_ENABLED_KEY = "is_scrubbing_mode_enabled"
+        const val PLAYBACK_SPEED_KEY = "playback_speed"
+        const val SUBTITLE_DELAY_KEY = "subtitle_delay"
+        const val SUBTITLE_SPEED_KEY = "subtitle_speed"
+        const val LOUDNESS_GAIN_KEY = "loudness_gain"
+        const val IS_LOUDNESS_GAIN_SUPPORTED_KEY = "is_loudness_gain_supported"
+        const val SHOULD_APPLY_VIDEO_FILTERS_KEY = "should_apply_video_filters"
+        const val IS_VIDEO_BRIGHTNESS_FILTER_ENABLED_KEY = "is_video_brightness_filter_enabled"
+        const val VIDEO_BRIGHTNESS_KEY = "video_brightness"
+        const val IS_VIDEO_CONTRAST_FILTER_ENABLED_KEY = "is_video_contrast_filter_enabled"
+        const val VIDEO_CONTRAST_KEY = "video_contrast"
+        const val IS_VIDEO_SATURATION_FILTER_ENABLED_KEY = "is_video_saturation_filter_enabled"
+        const val VIDEO_SATURATION_KEY = "video_saturation"
+        const val IS_VIDEO_HUE_FILTER_ENABLED_KEY = "is_video_hue_filter_enabled"
+        const val VIDEO_HUE_KEY = "video_hue"
+        const val IS_VIDEO_GAMMA_FILTER_ENABLED_KEY = "is_video_gamma_filter_enabled"
+        const val VIDEO_GAMMA_KEY = "video_gamma"
+        const val IS_VIDEO_SHARPENING_FILTER_ENABLED_KEY = "is_video_sharpening_filter_enabled"
+        const val VIDEO_SHARPENING_KEY = "video_sharpening"
+        const val SCREEN_ASPECT_RATIO_KEY = "screen_aspect_ratio"
+        const val IS_AMBIENCE_MODE_ENABLED_KEY = "is_ambience_mode_enabled"
+    }
+}
+
+fun MediaController.addSubtitleTrack(uri: Uri) {
+    val args = Bundle().apply {
+        putString(CustomCommands.SUBTITLE_TRACK_URI_KEY, uri.toString())
+    }
+    sendCustomCommand(CustomCommands.ADD_SUBTITLE_TRACK.sessionCommand, args)
+}
+
+fun MediaController.preciseSeekTo(positionMs: Long) {
+    val args = Bundle().apply {
+        putLong(CustomCommands.SEEK_POSITION_MS_KEY, positionMs)
+    }
+    sendCustomCommand(CustomCommands.PRECISE_SEEK_TO.sessionCommand, args)
+}
+
+suspend fun MediaController.setSkipSilenceEnabled(isEnabled: Boolean) {
+    val args = Bundle().apply {
+        putBoolean(CustomCommands.SKIP_SILENCE_ENABLED_KEY, isEnabled)
+    }
+    sendCustomCommand(CustomCommands.SET_SKIP_SILENCE_ENABLED.sessionCommand, args).await()
+}
+
+fun MediaController.setMediaControllerIsScrubbingModeEnabled(isEnabled: Boolean) {
+    val args = Bundle().apply {
+        putBoolean(CustomCommands.IS_SCRUBBING_MODE_ENABLED_KEY, isEnabled)
+    }
+    sendCustomCommand(CustomCommands.SET_IS_SCRUBBING_MODE_ENABLED.sessionCommand, args)
+}
+
+fun MediaController.setPersistentPlaybackSpeed(speed: Float) {
+    val args = Bundle().apply {
+        putFloat(CustomCommands.PLAYBACK_SPEED_KEY, speed)
+    }
+    sendCustomCommand(CustomCommands.SET_PERSISTENT_PLAYBACK_SPEED.sessionCommand, args)
+}
+
+fun MediaController.setTransientPlaybackSpeed(speed: Float) {
+    val args = Bundle().apply {
+        putFloat(CustomCommands.PLAYBACK_SPEED_KEY, speed)
+    }
+    sendCustomCommand(CustomCommands.SET_TRANSIENT_PLAYBACK_SPEED.sessionCommand, args)
+}
+
+suspend fun MediaController.isSkipSilenceEnabled(): Boolean {
+    val result = sendCustomCommand(CustomCommands.GET_SKIP_SILENCE_ENABLED.sessionCommand, Bundle.EMPTY)
+    return result.await().extras.getBoolean(CustomCommands.SKIP_SILENCE_ENABLED_KEY, false)
+}
+
+fun MediaController.setSubtitleDelayMilliseconds(delayMillis: Long) {
+    val args = Bundle().apply {
+        putLong(CustomCommands.SUBTITLE_DELAY_KEY, delayMillis)
+    }
+    sendCustomCommand(CustomCommands.SET_SUBTITLE_DELAY.sessionCommand, args)
+}
+
+suspend fun MediaController.getSubtitleDelayMilliseconds(): Long {
+    val result = sendCustomCommand(CustomCommands.GET_SUBTITLE_DELAY.sessionCommand, Bundle.EMPTY)
+    return result.await().extras.getLong(CustomCommands.SUBTITLE_DELAY_KEY, 0L)
+}
+
+fun MediaController.setSubtitleSpeed(speed: Float) {
+    val args = Bundle().apply {
+        putFloat(CustomCommands.SUBTITLE_SPEED_KEY, speed)
+    }
+    sendCustomCommand(CustomCommands.SET_SUBTITLE_SPEED.sessionCommand, args)
+}
+
+suspend fun MediaController.getSubtitleSpeed(): Float {
+    val result = sendCustomCommand(CustomCommands.GET_SUBTITLE_SPEED.sessionCommand, Bundle.EMPTY)
+    return result.await().extras.getFloat(CustomCommands.SUBTITLE_SPEED_KEY, 1f)
+}
+
+fun MediaController.stopPlayerSession() {
+    sendCustomCommand(CustomCommands.STOP_PLAYER_SESSION.sessionCommand, Bundle.EMPTY)
+}
+
+fun MediaController.setLoudnessGain(gain: Int) {
+    val args = Bundle().apply {
+        putInt(CustomCommands.LOUDNESS_GAIN_KEY, gain)
+    }
+    sendCustomCommand(CustomCommands.SET_LOUDNESS_GAIN.sessionCommand, args)
+}
+
+fun MediaController.previewVideoFilters(preferences: PlayerPreferences) {
+    val args = Bundle().apply {
+        putBoolean(CustomCommands.SHOULD_APPLY_VIDEO_FILTERS_KEY, preferences.shouldApplyVideoFilters)
+        putBoolean(CustomCommands.IS_AMBIENCE_MODE_ENABLED_KEY, preferences.isAmbienceModeEnabled)
+        putBoolean(CustomCommands.IS_VIDEO_BRIGHTNESS_FILTER_ENABLED_KEY, preferences.isVideoBrightnessFilterEnabled)
+        putFloat(CustomCommands.VIDEO_BRIGHTNESS_KEY, preferences.videoBrightness)
+        putBoolean(CustomCommands.IS_VIDEO_CONTRAST_FILTER_ENABLED_KEY, preferences.isVideoContrastFilterEnabled)
+        putFloat(CustomCommands.VIDEO_CONTRAST_KEY, preferences.videoContrast)
+        putBoolean(CustomCommands.IS_VIDEO_SATURATION_FILTER_ENABLED_KEY, preferences.isVideoSaturationFilterEnabled)
+        putFloat(CustomCommands.VIDEO_SATURATION_KEY, preferences.videoSaturation)
+        putBoolean(CustomCommands.IS_VIDEO_HUE_FILTER_ENABLED_KEY, preferences.isVideoHueFilterEnabled)
+        putFloat(CustomCommands.VIDEO_HUE_KEY, preferences.videoHue)
+        putBoolean(CustomCommands.IS_VIDEO_GAMMA_FILTER_ENABLED_KEY, preferences.isVideoGammaFilterEnabled)
+        putFloat(CustomCommands.VIDEO_GAMMA_KEY, preferences.videoGamma)
+        putBoolean(CustomCommands.IS_VIDEO_SHARPENING_FILTER_ENABLED_KEY, preferences.isVideoSharpeningFilterEnabled)
+        putFloat(CustomCommands.VIDEO_SHARPENING_KEY, preferences.videoSharpening)
+    }
+    sendCustomCommand(CustomCommands.PREVIEW_VIDEO_FILTERS.sessionCommand, args)
+}
+
+fun MediaController.setScreenAspectRatio(aspectRatio: Float) {
+    val args = Bundle().apply {
+        putFloat(CustomCommands.SCREEN_ASPECT_RATIO_KEY, aspectRatio)
+    }
+    sendCustomCommand(CustomCommands.SET_SCREEN_ASPECT_RATIO.sessionCommand, args)
+}
+
+suspend fun MediaController.getLoudnessGain(): Int {
+    val result = sendCustomCommand(CustomCommands.GET_LOUDNESS_GAIN.sessionCommand, Bundle.EMPTY)
+    return result.await().extras.getInt(CustomCommands.LOUDNESS_GAIN_KEY, 0)
+}
+
+suspend fun MediaController.isLoudnessGainSupported(): Boolean {
+    val result = sendCustomCommand(CustomCommands.IS_LOUDNESS_GAIN_SUPPORTED.sessionCommand, Bundle.EMPTY)
+    return result.await().extras.getBoolean(CustomCommands.IS_LOUDNESS_GAIN_SUPPORTED_KEY, false)
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/DecoderPriorityPolicy.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/DecoderPriorityPolicy.kt
new file mode 100644
index 000000000..f88f85894
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/DecoderPriorityPolicy.kt
@@ -0,0 +1,42 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.service
+
+import androidx.media3.exoplayer.DefaultRenderersFactory
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+
+internal fun DecoderPriority.extensionRendererMode(): Int = when (this) {
+    DecoderPriority.AUTOMATIC -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_OFF
+    DecoderPriority.AUTOMATIC_PREFER_DEVICE -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON
+    DecoderPriority.DEVICE_ONLY -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_OFF
+    DecoderPriority.PREFER_DEVICE -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON
+    DecoderPriority.PREFER_APP -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER
+}
+
+internal fun DecoderPriority.logName(): String = when (this) {
+    DecoderPriority.AUTOMATIC -> "AUTO_HW"
+    DecoderPriority.AUTOMATIC_PREFER_DEVICE -> "AUTO_HW_PLUS"
+    DecoderPriority.DEVICE_ONLY -> "HW"
+    DecoderPriority.PREFER_DEVICE -> "HW+"
+    DecoderPriority.PREFER_APP -> "SW"
+}
+
+internal fun DecoderPriority.shouldEnableDecoderFallback(): Boolean = this != DecoderPriority.DEVICE_ONLY
+
+internal fun DecoderPriority.shouldRetryWithSoftwareDecoder(): Boolean = when (this) {
+    DecoderPriority.AUTOMATIC,
+    DecoderPriority.AUTOMATIC_PREFER_DEVICE,
+    DecoderPriority.PREFER_DEVICE,
+    -> true
+    DecoderPriority.DEVICE_ONLY,
+    DecoderPriority.PREFER_APP,
+    -> false
+}
+
+internal fun DecoderPriority.shouldUseAudioExtensionFallback(): Boolean = when (this) {
+    DecoderPriority.AUTOMATIC,
+    DecoderPriority.AUTOMATIC_PREFER_DEVICE,
+    -> true
+    DecoderPriority.DEVICE_ONLY,
+    DecoderPriority.PREFER_DEVICE,
+    DecoderPriority.PREFER_APP,
+    -> false
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/NormalizingRenderersFactory.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/NormalizingRenderersFactory.kt
new file mode 100644
index 000000000..d6129d5fc
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/NormalizingRenderersFactory.kt
@@ -0,0 +1,64 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.service
+
+import android.content.Context
+import android.os.Handler
+import androidx.annotation.OptIn
+import androidx.media3.common.audio.AudioProcessor
+import androidx.media3.common.util.Log
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.Renderer
+import androidx.media3.exoplayer.audio.AudioRendererEventListener
+import androidx.media3.exoplayer.audio.AudioSink
+import androidx.media3.exoplayer.audio.DefaultAudioSink
+import androidx.media3.exoplayer.mediacodec.MediaCodecSelector
+import io.github.anilbeesetti.nextlib.media3ext.ffdecoder.FfmpegAudioRenderer
+import io.github.anilbeesetti.nextlib.media3ext.ffdecoder.NextRenderersFactory
+
+@OptIn(UnstableApi::class)
+class NormalizingRenderersFactory(
+    context: Context,
+    private val volumeNormalizationAudioProcessor: AudioProcessor,
+    private val shouldUseAudioExtensionFallback: Boolean,
+) : NextRenderersFactory(context) {
+
+    override fun buildAudioSink(
+        context: Context,
+        enableFloatOutput: Boolean,
+        enableAudioTrackPlaybackParams: Boolean,
+    ): AudioSink = DefaultAudioSink.Builder(context)
+        .setEnableFloatOutput(enableFloatOutput)
+        .setEnableAudioOutputPlaybackParameters(enableAudioTrackPlaybackParams)
+        .setAudioProcessors(arrayOf(volumeNormalizationAudioProcessor))
+        .build()
+
+    override fun buildAudioRenderers(
+        context: Context,
+        extensionRendererMode: Int,
+        mediaCodecSelector: MediaCodecSelector,
+        enableDecoderFallback: Boolean,
+        audioSink: AudioSink,
+        eventHandler: Handler,
+        eventListener: AudioRendererEventListener,
+        out: ArrayList<Renderer>,
+    ) {
+        super.buildAudioRenderers(
+            context,
+            extensionRendererMode,
+            mediaCodecSelector,
+            enableDecoderFallback,
+            audioSink,
+            eventHandler,
+            eventListener,
+            out,
+        )
+        if (!shouldUseAudioExtensionFallback || extensionRendererMode != EXTENSION_RENDERER_MODE_OFF) return
+
+        out.add(FfmpegAudioRenderer(eventHandler, eventListener, audioSink))
+        Log.i(TAG, "Loaded FfmpegAudioRenderer as audio fallback.")
+    }
+
+    private companion object {
+        private const val TAG = "NormalRenderersFactory"
+    }
+
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoEffectsPolicy.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoEffectsPolicy.kt
new file mode 100644
index 000000000..ceee07560
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoEffectsPolicy.kt
@@ -0,0 +1,5 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.service
+
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+
+internal fun shouldApplyVideoEffects(decoderPriority: DecoderPriority): Boolean = decoderPriority != DecoderPriority.PREFER_APP
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoEffectsState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoEffectsState.kt
new file mode 100644
index 000000000..65957e1c6
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoEffectsState.kt
@@ -0,0 +1,9 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.service
+
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+
+internal data class VideoEffectsState(
+    val filters: VideoFilterPreferences,
+    val decoderPriority: DecoderPriority,
+    val isPipelineInitialized: Boolean = false,
+)
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoFilterPreferences.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoFilterPreferences.kt
new file mode 100644
index 000000000..27872dc0e
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoFilterPreferences.kt
@@ -0,0 +1,88 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.service
+
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+
+data class VideoFilterPreferences(
+    val shouldApply: Boolean,
+    val isAmbienceModeEnabled: Boolean,
+    val screenAspectRatio: Float,
+    val isBrightnessEnabled: Boolean,
+    val brightness: Float,
+    val isContrastEnabled: Boolean,
+    val contrast: Float,
+    val isSaturationEnabled: Boolean,
+    val saturation: Float,
+    val isHueEnabled: Boolean,
+    val hue: Float,
+    val isGammaEnabled: Boolean,
+    val gamma: Float,
+    val isSharpeningEnabled: Boolean,
+    val sharpening: Float,
+) {
+    fun interpolateTo(
+        target: VideoFilterPreferences,
+        fraction: Float,
+    ): VideoFilterPreferences {
+        if (fraction >= 1f) return target
+
+        return VideoFilterPreferences(
+            shouldApply = shouldApply || target.shouldApply,
+            isAmbienceModeEnabled = target.isAmbienceModeEnabled,
+            screenAspectRatio = target.screenAspectRatio,
+            isBrightnessEnabled = isBrightnessEnabled || target.isBrightnessEnabled,
+            brightness = brightness.interpolate(target.brightness, fraction),
+            isContrastEnabled = isContrastEnabled || target.isContrastEnabled,
+            contrast = contrast.interpolate(target.contrast, fraction),
+            isSaturationEnabled = isSaturationEnabled || target.isSaturationEnabled,
+            saturation = saturation.interpolate(target.saturation, fraction),
+            isHueEnabled = isHueEnabled || target.isHueEnabled,
+            hue = hue.interpolate(target.hue, fraction),
+            isGammaEnabled = isGammaEnabled || target.isGammaEnabled,
+            gamma = gamma.interpolate(target.gamma, fraction),
+            isSharpeningEnabled = isSharpeningEnabled || target.isSharpeningEnabled,
+            sharpening = sharpening.interpolate(target.sharpening, fraction),
+        )
+    }
+
+    fun shouldCreateEffect(): Boolean = shouldApply &&
+        (
+            isAmbienceModeEnabled ||
+            isBrightnessEnabled &&
+                brightness != PlayerPreferences.DEFAULT_VIDEO_BRIGHTNESS ||
+                isContrastEnabled &&
+                contrast != PlayerPreferences.DEFAULT_VIDEO_CONTRAST ||
+                isSaturationEnabled &&
+                saturation != PlayerPreferences.DEFAULT_VIDEO_SATURATION ||
+                isHueEnabled &&
+                hue != PlayerPreferences.DEFAULT_VIDEO_HUE ||
+                isGammaEnabled &&
+                gamma != PlayerPreferences.DEFAULT_VIDEO_GAMMA ||
+                isSharpeningEnabled &&
+                sharpening != PlayerPreferences.DEFAULT_VIDEO_SHARPENING
+            )
+
+    companion object {
+        fun default(): VideoFilterPreferences = VideoFilterPreferences(
+            shouldApply = false,
+            isAmbienceModeEnabled = false,
+            screenAspectRatio = 0f,
+            isBrightnessEnabled = false,
+            brightness = PlayerPreferences.DEFAULT_VIDEO_BRIGHTNESS,
+            isContrastEnabled = false,
+            contrast = PlayerPreferences.DEFAULT_VIDEO_CONTRAST,
+            isSaturationEnabled = false,
+            saturation = PlayerPreferences.DEFAULT_VIDEO_SATURATION,
+            isHueEnabled = false,
+            hue = PlayerPreferences.DEFAULT_VIDEO_HUE,
+            isGammaEnabled = false,
+            gamma = PlayerPreferences.DEFAULT_VIDEO_GAMMA,
+            isSharpeningEnabled = false,
+            sharpening = PlayerPreferences.DEFAULT_VIDEO_SHARPENING,
+        )
+    }
+}
+
+internal fun Float.interpolate(
+    target: Float,
+    fraction: Float,
+): Float = this + (target - this) * fraction
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoFilterTransition.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoFilterTransition.kt
new file mode 100644
index 000000000..df733c41e
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoFilterTransition.kt
@@ -0,0 +1,49 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.service
+
+import android.os.SystemClock
+
+internal data class VideoFilterTransition(
+    val startFilters: VideoFilterPreferences,
+    val targetFilters: VideoFilterPreferences,
+    val startMs: Long,
+) {
+    fun currentFilters(
+        currentMs: Long,
+        durationMs: Long,
+    ): VideoFilterPreferences = startFilters.interpolateTo(
+        target = targetFilters,
+        fraction = progress(currentMs, durationMs),
+    )
+
+    fun progress(
+        currentMs: Long,
+        durationMs: Long,
+    ): Float {
+        if (startFilters == targetFilters) return 1f
+        return ((currentMs - startMs).toFloat() / durationMs).coerceIn(0f, 1f)
+    }
+
+    fun to(
+        targetFilters: VideoFilterPreferences,
+        startMs: Long,
+        durationMs: Long,
+    ): VideoFilterTransition = VideoFilterTransition(
+        startFilters = currentFilters(
+            currentMs = startMs,
+            durationMs = durationMs,
+        ),
+        targetFilters = targetFilters,
+        startMs = startMs,
+    )
+
+    companion object {
+        fun default(): VideoFilterTransition {
+            val defaultFilters = VideoFilterPreferences.default()
+            return VideoFilterTransition(
+                startFilters = defaultFilters,
+                targetFilters = defaultFilters,
+                startMs = SystemClock.elapsedRealtime(),
+            )
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoFiltersEffect.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoFiltersEffect.kt
new file mode 100644
index 000000000..836df3818
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VideoFiltersEffect.kt
@@ -0,0 +1,294 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.service
+
+import android.content.Context
+import android.opengl.GLES20
+import android.os.SystemClock
+import androidx.annotation.OptIn
+import androidx.media3.common.VideoFrameProcessingException
+import androidx.media3.common.util.GlProgram
+import androidx.media3.common.util.GlUtil
+import androidx.media3.common.util.Size
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.effect.BaseGlShaderProgram
+import androidx.media3.effect.GlEffect
+import androidx.media3.effect.GlShaderProgram
+
+@OptIn(UnstableApi::class)
+internal class VideoFiltersEffect(
+    private var transition: VideoFilterTransition,
+    private val transitionDurationMs: Long,
+) : GlEffect {
+
+    fun updateTransition(transition: VideoFilterTransition) {
+        this.transition = transition
+    }
+
+    override fun toGlShaderProgram(
+        context: Context,
+        useHdr: Boolean,
+    ): GlShaderProgram = VideoFiltersShaderProgram(
+        useHdr = useHdr,
+        effect = this,
+        transitionDurationMs = transitionDurationMs,
+    )
+
+    override fun isNoOp(
+        inputWidth: Int,
+        inputHeight: Int,
+    ): Boolean = false
+
+    internal fun getCurrentFilters(currentMs: Long): VideoFilterPreferences = transition.currentFilters(
+        currentMs = currentMs,
+        durationMs = transitionDurationMs,
+    )
+
+    internal fun getTargetFilters(): VideoFilterPreferences = transition.targetFilters
+
+    private class VideoFiltersShaderProgram(
+        useHdr: Boolean,
+        private val effect: VideoFiltersEffect,
+        private val transitionDurationMs: Long,
+    ) : BaseGlShaderProgram(useHdr, 1) {
+
+        private val glProgram = createGlProgram()
+        private var inputWidth = 1
+        private var inputHeight = 1
+
+        init {
+            val identityMatrix = GlUtil.create4x4IdentityMatrix()
+            glProgram.setBufferAttribute(
+                "aFramePosition",
+                GlUtil.getNormalizedCoordinateBounds(),
+                POSITION_COMPONENT_COUNT,
+            )
+            glProgram.setFloatsUniform("uTransformationMatrix", identityMatrix)
+            glProgram.setFloatsUniform("uTexTransformationMatrix", identityMatrix)
+        }
+
+        override fun configure(
+            inputWidth: Int,
+            inputHeight: Int,
+        ): Size {
+            this.inputWidth = inputWidth
+            this.inputHeight = inputHeight
+            val filters = effect.getTargetFilters()
+            val outputSize = if (filters.isAmbienceModeEnabled && filters.screenAspectRatio > 0f) {
+                val inputAspectRatio = inputWidth.toFloat() / inputHeight
+                if (filters.screenAspectRatio > inputAspectRatio) {
+                    // Screen is wider than video (pillarbox)
+                    Size((inputHeight * filters.screenAspectRatio).toInt(), inputHeight)
+                } else {
+                    // Screen is taller than video (letterbox)
+                    Size(inputWidth, (inputWidth / filters.screenAspectRatio).toInt())
+                }
+            } else {
+                Size(inputWidth, inputHeight)
+            }
+
+            glProgram.setFloatsUniform(
+                "uTexelSize",
+                floatArrayOf(
+                    1f / inputWidth,
+                    1f / inputHeight,
+                ),
+            )
+            return outputSize
+        }
+
+        override fun drawFrame(
+            inputTexId: Int,
+            presentationTimeUs: Long,
+        ) {
+            try {
+                glProgram.use()
+                val filters = effect.getCurrentFilters(SystemClock.elapsedRealtime())
+                setFilterUniforms(filters)
+
+                if (filters.isAmbienceModeEnabled && filters.screenAspectRatio > 0f) {
+                    val inputAr = inputWidth.toFloat() / inputHeight
+                    val screenAr = filters.screenAspectRatio
+                    
+                    val scaleX = if (screenAr > inputAr) screenAr / inputAr else 1.0f
+                    val scaleY = if (inputAr > screenAr) inputAr / screenAr else 1.0f
+                    
+                    glProgram.setFloatUniform("uScaleX", scaleX)
+                    glProgram.setFloatUniform("uScaleY", scaleY)
+                    glProgram.setFloatUniform("uAmbienceEnabled", 1.0f)
+                } else {
+                    glProgram.setFloatUniform("uScaleX", 1.0f)
+                    glProgram.setFloatUniform("uScaleY", 1.0f)
+                    glProgram.setFloatUniform("uAmbienceEnabled", 0.0f)
+                }
+
+                glProgram.setSamplerTexIdUniform("uTexSampler", inputTexId, 0)
+                glProgram.bindAttributesAndUniforms()
+                GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, VERTEX_COUNT)
+                GlUtil.checkGlError()
+            } catch (exception: GlUtil.GlException) {
+                throw VideoFrameProcessingException(exception, presentationTimeUs)
+            }
+        }
+
+        override fun release() {
+            super.release()
+            try {
+                glProgram.delete()
+            } catch (exception: GlUtil.GlException) {
+                throw VideoFrameProcessingException(exception)
+            }
+        }
+
+        private fun setFilterUniforms(filters: VideoFilterPreferences) {
+            glProgram.setFloatUniform("uBrightness", filters.brightness)
+            glProgram.setFloatUniform("uContrast", filters.contrast)
+            glProgram.setFloatUniform("uSaturation", filters.saturation)
+            glProgram.setFloatUniform("uHue", filters.hue)
+            glProgram.setFloatUniform("uGamma", filters.gamma)
+            val sharpness = kotlin.math.sqrt(filters.sharpening.coerceAtLeast(0f)) * SHARPNESS_SCALE
+            glProgram.setFloatUniform("uSharpness", sharpness)
+        }
+
+        private fun createGlProgram(): GlProgram = try {
+            GlProgram(VERTEX_SHADER, FRAGMENT_SHADER)
+        } catch (exception: GlUtil.GlException) {
+            throw VideoFrameProcessingException(exception)
+        }
+    }
+
+    private companion object {
+        private const val POSITION_COMPONENT_COUNT = 4
+        private const val VERTEX_COUNT = 4
+        private const val SHARPNESS_SCALE = 1.0f
+
+        private const val VERTEX_SHADER = """
+            #version 100
+            attribute vec4 aFramePosition;
+            uniform mat4 uTransformationMatrix;
+            uniform mat4 uTexTransformationMatrix;
+            varying vec2 vTexSamplingCoord;
+
+            void main() {
+              gl_Position = uTransformationMatrix * aFramePosition;
+              vec4 texturePosition = vec4(aFramePosition.x * 0.5 + 0.5,
+                                          aFramePosition.y * 0.5 + 0.5, 0.0, 1.0);
+              vTexSamplingCoord = (uTexTransformationMatrix * texturePosition).xy;
+            }
+        """
+
+        private const val FRAGMENT_SHADER = """
+            #version 100
+            precision highp float;
+            uniform sampler2D uTexSampler;
+            uniform vec2 uTexelSize;
+            uniform float uBrightness;
+            uniform float uContrast;
+            uniform float uSaturation;
+            uniform float uHue;
+            uniform float uGamma;
+            uniform float uSharpness;
+            uniform float uScaleX;
+            uniform float uScaleY;
+            uniform float uAmbienceEnabled;
+            varying vec2 vTexSamplingCoord;
+
+            float hash(vec2 p) {
+              return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+            }
+
+            vec3 rotateHue(vec3 color, float hue) {
+              float angle = hue * 0.01745329252;
+              float sine = sin(angle);
+              float cosine = cos(angle);
+              vec3 yiq = vec3(
+                dot(color, vec3(0.299, 0.587, 0.114)),
+                dot(color, vec3(0.596, -0.274, -0.322)),
+                dot(color, vec3(0.211, -0.523, 0.312))
+              );
+              vec2 chroma = vec2(
+                yiq.y * cosine - yiq.z * sine,
+                yiq.y * sine + yiq.z * cosine
+              );
+              yiq = vec3(yiq.x, chroma.x, chroma.y);
+              return vec3(
+                dot(yiq, vec3(1.0, 0.956, 0.621)),
+                dot(yiq, vec3(1.0, -0.272, -0.647)),
+                dot(yiq, vec3(1.0, -1.106, 1.703))
+              );
+            }
+
+            vec3 applyColorFilters(vec3 color) {
+              float luma;
+
+              if (uBrightness != 0.0) {
+                color = clamp(color + vec3(uBrightness), 0.0, 1.0);
+              }
+              if (uContrast != 0.0) {
+                color = clamp((color - vec3(0.5)) * (1.0 + uContrast) + vec3(0.5), 0.0, 1.0);
+              }
+              if (uHue != 0.0) {
+                color = clamp(rotateHue(color, uHue), 0.0, 1.0);
+              }
+              if (uSaturation != 0.0) {
+                luma = dot(color, vec3(0.299, 0.587, 0.114));
+                color = clamp(mix(vec3(luma), color, 1.0 + uSaturation / 100.0), 0.0, 1.0);
+              }
+              if (uGamma != 1.0) {
+                color = clamp(pow(color, vec3(1.0 / max(uGamma, 0.1))), 0.0, 1.0);
+              }
+              return color;
+            }
+
+            void main() {
+              vec2 video_uv = (vTexSamplingCoord - 0.5) * vec2(uScaleX, uScaleY) + 0.5;
+              vec4 color;
+
+              if (uAmbienceEnabled > 0.5 && (video_uv.x < 0.0 || video_uv.x > 1.0 || video_uv.y < 0.0 || video_uv.y > 1.0)) {
+                // Ambient region
+                vec3 avg_color = vec3(0.0);
+                const int samples = 20;
+                float base_seed = 42.0;
+                
+                for (int i = 0; i < samples; i++) {
+                  float seed = base_seed + float(i) * 0.618034;
+                  float x = hash(vec2(seed, 0.123));
+                  float y = hash(vec2(seed, 0.456));
+                  avg_color += texture2D(uTexSampler, vec2(x, y)).rgb;
+                }
+                avg_color /= float(samples);
+
+                float luma = dot(avg_color, vec3(0.2126, 0.7152, 0.0722));
+                avg_color = mix(vec3(luma), avg_color, 1.3); // Saturation boost
+                avg_color *= 0.30; // Brightness
+
+                vec2 edge_uv = clamp(video_uv, 0.0, 1.0);
+                float dist = length(video_uv - edge_uv);
+                float fade = exp(-dist * 2.5);
+                avg_color *= fade;
+
+                float dither = hash(vTexSamplingCoord * 1000.0) * 0.004 - 0.002;
+                color = vec4(clamp(avg_color + dither, 0.0, 1.0), 1.0);
+              } else {
+                vec2 sample_uv = clamp(video_uv, 0.0, 1.0);
+                vec4 center = texture2D(uTexSampler, sample_uv);
+                vec3 sourceColor = center.rgb;
+
+                if (uSharpness > 0.0) {
+                  vec3 north = texture2D(uTexSampler, sample_uv + vec2(0.0, -uTexelSize.y)).rgb;
+                  vec3 south = texture2D(uTexSampler, sample_uv + vec2(0.0, uTexelSize.y)).rgb;
+                  vec3 west = texture2D(uTexSampler, sample_uv + vec2(-uTexelSize.x, 0.0)).rgb;
+                  vec3 east = texture2D(uTexSampler, sample_uv + vec2(uTexelSize.x, 0.0)).rgb;
+                  vec3 northwest = texture2D(uTexSampler, sample_uv + vec2(-uTexelSize.x, -uTexelSize.y)).rgb;
+                  vec3 northeast = texture2D(uTexSampler, sample_uv + vec2(uTexelSize.x, -uTexelSize.y)).rgb;
+                  vec3 southwest = texture2D(uTexSampler, sample_uv + vec2(-uTexelSize.x, uTexelSize.y)).rgb;
+                  vec3 southeast = texture2D(uTexSampler, sample_uv + vec2(uTexelSize.x, uTexelSize.y)).rgb;
+                  vec3 blur = center.rgb * 0.25 + (north + south + west + east) * 0.125 + (northwest + northeast + southwest + southeast) * 0.0625;
+                  sourceColor = clamp(center.rgb + (center.rgb - blur) * uSharpness, 0.0, 1.0);
+                }
+                color = vec4(applyColorFilters(sourceColor), center.a);
+              }
+
+              gl_FragColor = color;
+            }
+        """
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VolumeNormalizationAudioProcessor.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VolumeNormalizationAudioProcessor.kt
new file mode 100644
index 000000000..87adf2413
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/service/VolumeNormalizationAudioProcessor.kt
@@ -0,0 +1,165 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.service
+
+import androidx.annotation.OptIn
+import androidx.media3.common.C
+import androidx.media3.common.audio.AudioProcessor.AudioFormat
+import androidx.media3.common.audio.AudioProcessor.StreamMetadata
+import androidx.media3.common.audio.BaseAudioProcessor
+import androidx.media3.common.util.UnstableApi
+import java.nio.ByteBuffer
+import kotlin.math.abs
+import kotlin.math.absoluteValue
+import kotlin.math.min
+import kotlin.math.roundToInt
+import kotlin.math.sqrt
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+
+@OptIn(UnstableApi::class)
+class VolumeNormalizationAudioProcessor : BaseAudioProcessor() {
+
+    @Volatile
+    var isEnabled: Boolean = false
+
+    private var currentGain = 1f
+    private var hasLoggedProcessing = false
+    private var lastLoggedGain = 1f
+
+    override fun onConfigure(inputAudioFormat: AudioFormat): AudioFormat = if (inputAudioFormat.encoding == C.ENCODING_PCM_16BIT) {
+        inputAudioFormat
+    } else {
+        AudioFormat.NOT_SET
+    }
+
+    override fun queueInput(inputBuffer: ByteBuffer) {
+        val position = inputBuffer.position()
+        val limit = inputBuffer.limit()
+        val size = limit - position
+        val outputBuffer = replaceOutputBuffer(size)
+        val shouldNormalize = isEnabled
+        if (!shouldNormalize || size < BYTES_PER_SAMPLE) {
+            currentGain = 1f
+            copyInput(inputBuffer, outputBuffer, position, limit)
+            inputBuffer.position(limit)
+            outputBuffer.flip()
+            return
+        }
+
+        if (!hasLoggedProcessing) {
+            hasLoggedProcessing = true
+            Logger.debug(TAG, "Volume normalization processing: encoding=${inputAudioFormat.encoding}, bytes=$size")
+        }
+        val gain = calculateGain(inputBuffer, position, limit)
+        logGainChange(gain)
+        applyGain(inputBuffer, outputBuffer, position, limit, gain)
+        inputBuffer.position(limit)
+        outputBuffer.flip()
+    }
+
+    override fun onFlush(streamMetadata: StreamMetadata) {
+        currentGain = 1f
+        hasLoggedProcessing = false
+        lastLoggedGain = 1f
+    }
+
+    override fun onReset() {
+        currentGain = 1f
+        hasLoggedProcessing = false
+        lastLoggedGain = 1f
+    }
+
+    private fun calculateGain(
+        inputBuffer: ByteBuffer,
+        position: Int,
+        limit: Int,
+    ): Float {
+        var sumSquares = 0.0
+        var peak = 0
+        var sampleCount = 0
+        var index = position
+        while (index + 1 < limit) {
+            val sample = inputBuffer.readLittleEndianShort(index)
+            sumSquares += (sample / MAX_SAMPLE_VALUE) * (sample / MAX_SAMPLE_VALUE)
+            peak = maxOf(peak, abs(sample))
+            sampleCount++
+            index += BYTES_PER_SAMPLE
+        }
+        if (sampleCount == 0) return currentGain
+
+        val rms = sqrt(sumSquares / sampleCount).toFloat()
+        if (rms <= SILENCE_RMS || peak == 0) return currentGain
+
+        // 用短时 RMS 估计增益，峰值只负责防止削波。
+        val rmsGain = TARGET_RMS / rms
+        val peakGain = MAX_PEAK_SAMPLE / peak.toFloat()
+        val targetGain = min(rmsGain, peakGain).coerceIn(MIN_GAIN, MAX_GAIN)
+        val smoothing = if (targetGain < currentGain) GAIN_REDUCTION_SMOOTHING else GAIN_INCREASE_SMOOTHING
+        val smoothedGain = currentGain + (targetGain - currentGain) * smoothing
+        currentGain = min(smoothedGain, peakGain).coerceIn(MIN_GAIN, MAX_GAIN)
+        return currentGain
+    }
+
+    private fun logGainChange(gain: Float) {
+        if ((gain - lastLoggedGain).absoluteValue < LOG_GAIN_DELTA) return
+        lastLoggedGain = gain
+        Logger.debug(TAG, "Volume normalization gain=${gain.formatGainForLog()}")
+    }
+
+    private fun copyInput(
+        inputBuffer: ByteBuffer,
+        outputBuffer: ByteBuffer,
+        position: Int,
+        limit: Int,
+    ) {
+        for (index in position until limit) {
+            outputBuffer.put(inputBuffer.get(index))
+        }
+    }
+
+    private fun applyGain(
+        inputBuffer: ByteBuffer,
+        outputBuffer: ByteBuffer,
+        position: Int,
+        limit: Int,
+        gain: Float,
+    ) {
+        var index = position
+        while (index + 1 < limit) {
+            val sample = inputBuffer.readLittleEndianShort(index)
+            val scaledSample = (sample * gain)
+                .roundToInt()
+                .coerceIn(Short.MIN_VALUE.toInt(), Short.MAX_VALUE.toInt())
+            outputBuffer.writeLittleEndianShort(scaledSample)
+            index += BYTES_PER_SAMPLE
+        }
+        if (index < limit) {
+            outputBuffer.put(inputBuffer.get(index))
+        }
+    }
+
+    private fun Float.formatGainForLog(): String = ((this * 100).roundToInt() / 100f).toString()
+
+    private fun ByteBuffer.readLittleEndianShort(index: Int): Int {
+        val low = get(index).toInt() and 0xFF
+        val high = get(index + 1).toInt()
+        return ((high shl 8) or low).toShort().toInt()
+    }
+
+    private fun ByteBuffer.writeLittleEndianShort(value: Int) {
+        put((value and 0xFF).toByte())
+        put(((value shr 8) and 0xFF).toByte())
+    }
+
+    private companion object {
+        private const val TAG = "VolumeNormalization"
+        private const val BYTES_PER_SAMPLE = 2
+        private const val MAX_SAMPLE_VALUE = 32768.0
+        private const val TARGET_RMS = 0.14f
+        private const val SILENCE_RMS = 0.001f
+        private const val MIN_GAIN = 0.25f
+        private const val MAX_GAIN = 3f
+        private const val MAX_PEAK_SAMPLE = 30_000f
+        private const val GAIN_REDUCTION_SMOOTHING = 0.55f
+        private const val GAIN_INCREASE_SMOOTHING = 0.08f
+        private const val LOG_GAIN_DELTA = 0.5f
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/BrightnessState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/BrightnessState.kt
new file mode 100644
index 000000000..24b01b5d2
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/BrightnessState.kt
@@ -0,0 +1,60 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import android.view.WindowManager
+import androidx.activity.compose.LocalActivity
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.DisposableEffectResult
+import androidx.compose.runtime.DisposableEffectScope
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.core.util.Consumer
+import app.gyrolet.mpvrx.exoplayer.ExoPlayerActivity
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.brightnessPercentage
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.currentBrightness
+
+@Composable
+fun rememberBrightnessState(): BrightnessState {
+    val activity = LocalActivity.current
+    val brightnessState = remember { BrightnessState(activity as ExoPlayerActivity) }
+    DisposableEffect(activity) { brightnessState.handleListeners(this) }
+    return brightnessState
+}
+
+@Stable
+class BrightnessState(
+    private val activity: ExoPlayerActivity,
+) {
+    val maxBrightness: Float = WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_FULL
+    var currentBrightness: Float by mutableFloatStateOf(activity.currentBrightness)
+        private set
+
+    var brightnessPercentage: Int by mutableIntStateOf(activity.brightnessPercentage)
+        private set
+
+    fun updateBrightnessPercentage(percentage: Int) {
+        setBrightness(brightness = percentage.coerceIn(0, 100) * maxBrightness / 100)
+    }
+
+    fun setBrightness(brightness: Float) {
+        val windowAttributes = activity.window.attributes
+        windowAttributes.screenBrightness = brightness.coerceIn(0f, maxBrightness)
+        activity.window.attributes = windowAttributes
+    }
+
+    fun handleListeners(disposableEffectScope: DisposableEffectScope): DisposableEffectResult = with(disposableEffectScope) {
+        val windowAttributesChangedListener: Consumer<WindowManager.LayoutParams?> = Consumer {
+            currentBrightness = activity.currentBrightness
+            brightnessPercentage = activity.brightnessPercentage
+        }
+        activity.addOnWindowAttributesChangedListener(windowAttributesChangedListener)
+
+        onDispose {
+            activity.removeOnWindowAttributesChangedListener(windowAttributesChangedListener)
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/ControlsVisibilityState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/ControlsVisibilityState.kt
new file mode 100644
index 000000000..e03a8dee6
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/ControlsVisibilityState.kt
@@ -0,0 +1,99 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.activity.compose.LocalActivity
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import kotlin.time.Duration
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.togglePlayerSystemBars
+
+@Composable
+fun rememberControlsVisibilityState(player: Player, hideAfter: Duration): ControlsVisibilityState {
+    val activity = LocalActivity.current
+    val coroutineScope = rememberCoroutineScope()
+    val controlsVisibilityState = remember { ControlsVisibilityState(player, hideAfter, coroutineScope) }
+    LaunchedEffect(player) { controlsVisibilityState.observe() }
+    LaunchedEffect(controlsVisibilityState.isControlsVisible, controlsVisibilityState.isControlsLocked) {
+        if (controlsVisibilityState.isControlsLocked) {
+            activity?.togglePlayerSystemBars(shouldShowControls = false)
+            return@LaunchedEffect
+        }
+        activity?.togglePlayerSystemBars(
+            shouldShowControls = controlsVisibilityState.isControlsVisible,
+        )
+    }
+    return controlsVisibilityState
+}
+
+@Stable
+class ControlsVisibilityState(
+    private val player: Player,
+    private val hideAfter: Duration,
+    private val scope: CoroutineScope,
+) {
+    private var autoHideControlsJob: Job? = null
+
+    var isControlsVisible: Boolean by mutableStateOf(true)
+        private set
+
+    var isControlsLocked: Boolean by mutableStateOf(false)
+        private set
+
+    fun showControls(duration: Duration = hideAfter) {
+        isControlsVisible = true
+        autoHideControls(duration)
+    }
+
+    fun hideControls() {
+        autoHideControlsJob?.cancel()
+        isControlsVisible = false
+    }
+
+    fun toggleControlsVisibility() {
+        if (isControlsVisible) {
+            hideControls()
+        } else {
+            showControls()
+        }
+    }
+
+    fun lockControls() {
+        isControlsLocked = true
+    }
+
+    fun unlockControls() {
+        isControlsLocked = false
+        showControls()
+    }
+
+    suspend fun observe() {
+        player.listen { events ->
+            if (events.contains(Player.EVENT_IS_PLAYING_CHANGED)) {
+                if (player.isPlaying) {
+                    autoHideControls()
+                }
+            }
+        }
+    }
+
+    private fun autoHideControls(duration: Duration = hideAfter) {
+        autoHideControlsJob?.cancel()
+        autoHideControlsJob = scope.launch {
+            delay(duration)
+            if (player.isPlaying) {
+                isControlsVisible = false
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/CuesState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/CuesState.kt
new file mode 100644
index 000000000..d6ea8ef00
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/CuesState.kt
@@ -0,0 +1,36 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import androidx.media3.common.text.Cue
+import androidx.media3.common.util.UnstableApi
+
+@UnstableApi
+@Composable
+fun rememberCuesState(player: Player): CuesState {
+    val cuesState = remember { CuesState(player) }
+    LaunchedEffect(player) { cuesState.observe() }
+    return cuesState
+}
+
+class CuesState(
+    private val player: Player,
+) {
+    var cues: List<Cue> by mutableStateOf(emptyList())
+        private set
+
+    suspend fun observe() {
+        cues = player.currentCues.cues
+        player.listen { events ->
+            if (events.contains(Player.EVENT_CUES)) {
+                cues = player.currentCues.cues
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/ErrorState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/ErrorState.kt
new file mode 100644
index 000000000..6d2c2949a
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/ErrorState.kt
@@ -0,0 +1,40 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import androidx.media3.common.util.UnstableApi
+
+@UnstableApi
+@Composable
+fun rememberErrorState(player: Player): ErrorState {
+    val errorState = remember { ErrorState(player) }
+    LaunchedEffect(player) { errorState.observe() }
+    return errorState
+}
+
+class ErrorState(
+    private val player: Player,
+) {
+    var error: PlaybackException? by mutableStateOf(null)
+        private set
+
+    fun dismiss() {
+        error = null
+    }
+
+    suspend fun observe() {
+        error = player.playerError
+        player.listen { events ->
+            if (events.contains(Player.EVENT_PLAYER_ERROR)) {
+                error = player.playerError
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/MediaPresentationState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/MediaPresentationState.kt
new file mode 100644
index 000000000..5edea17a7
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/MediaPresentationState.kt
@@ -0,0 +1,191 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.annotation.IntRange
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.media3.common.C
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.Player
+import androidx.media3.common.VideoSize
+import androidx.media3.common.listen
+import androidx.media3.common.util.UnstableApi
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.formatted
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.hasRenderedFirstFrame
+
+@UnstableApi
+@Composable
+fun rememberMediaPresentationState(player: Player): MediaPresentationState {
+    val mediaPresentationState = remember { MediaPresentationState(player) }
+    LaunchedEffect(player) { mediaPresentationState.observe() }
+    return mediaPresentationState
+}
+
+@Stable
+class MediaPresentationState(
+    private val player: Player,
+    @param:IntRange(from = 0) private val tickIntervalMs: Long = 500,
+) {
+    private var pauseDiagnosticsJob: Job? = null
+    var position: Long by mutableLongStateOf(0L)
+        private set
+
+    var duration: Long by mutableLongStateOf(0L)
+        private set
+
+    var isPlaying: Boolean by mutableStateOf(false)
+        private set
+
+    var isLoading: Boolean by mutableStateOf(true)
+        private set
+
+    var isBuffering: Boolean by mutableStateOf(false)
+        private set
+
+    var hasRenderedFirstFrame: Boolean by mutableStateOf(false)
+        private set
+
+    suspend fun observe() {
+        updatePosition()
+        updateDuration()
+        isPlaying = player.isPlaying
+        isLoading = player.isLoading
+        isBuffering = player.playbackState == Player.STATE_BUFFERING
+        hasRenderedFirstFrame = player.mediaMetadata.hasRenderedFirstFrame
+
+        coroutineScope {
+            val diagnosticsScope = this
+            launch {
+                player.listen { events ->
+                    if (events.containsAny(
+                            Player.EVENT_MEDIA_ITEM_TRANSITION,
+                            Player.EVENT_MEDIA_METADATA_CHANGED,
+                            Player.EVENT_TIMELINE_CHANGED,
+                            Player.EVENT_PLAYBACK_STATE_CHANGED,
+                        )
+                    ) {
+                        updateDuration()
+                    }
+
+                    if (events.contains(Player.EVENT_PLAYBACK_STATE_CHANGED)) {
+                        this@MediaPresentationState.isBuffering = player.playbackState == Player.STATE_BUFFERING
+                        logPlaybackDiagnostics("playbackState")
+                    }
+
+                    if (events.contains(Player.EVENT_MEDIA_ITEM_TRANSITION)) {
+                        this@MediaPresentationState.hasRenderedFirstFrame = false
+                        logPlaybackDiagnostics("mediaItemTransition")
+                    }
+
+                    if (events.contains(Player.EVENT_RENDERED_FIRST_FRAME)) {
+                        this@MediaPresentationState.hasRenderedFirstFrame = true
+                        logPlaybackDiagnostics("renderedFirstFrame")
+                    }
+
+                    if (events.contains(Player.EVENT_VIDEO_SIZE_CHANGED)) {
+                        logVideoSize(player.videoSize)
+                    }
+
+                    if (events.contains(Player.EVENT_PLAYER_ERROR)) {
+                        logPlayerError(player.playerError)
+                    }
+
+                    if (events.contains(Player.EVENT_IS_PLAYING_CHANGED)) {
+                        this@MediaPresentationState.isPlaying = player.isPlaying
+                        logPlaybackDiagnostics("isPlayingChanged")
+                        schedulePauseDiagnostics(diagnosticsScope)
+                    }
+
+                    if (events.contains(Player.EVENT_POSITION_DISCONTINUITY)) {
+                        updatePosition()
+                        logPlaybackDiagnostics("positionDiscontinuity")
+                    }
+
+                    if (events.containsAny(Player.EVENT_IS_LOADING_CHANGED)) {
+                        this@MediaPresentationState.isLoading = player.isLoading
+                        logPlaybackDiagnostics("loadingChanged")
+                    }
+                }
+            }
+
+            while (true) {
+                delay(tickIntervalMs)
+                if (player.isPlaying) {
+                    updatePosition()
+                }
+                if (duration == 0L) {
+                    updateDuration()
+                }
+            }
+        }
+    }
+
+    private fun updatePosition() {
+        position = player.currentPosition.coerceAtLeast(0L)
+    }
+
+    private fun updateDuration() {
+        duration = player.duration
+            .takeIf { it != C.TIME_UNSET && it > 0L }
+            ?: player.mediaMetadata.durationMs?.takeIf { it > 0L }
+            ?: 0L
+    }
+
+    private fun schedulePauseDiagnostics(scope: CoroutineScope) {
+        pauseDiagnosticsJob?.cancel()
+        if (player.isPlaying) return
+        pauseDiagnosticsJob = scope.launch {
+            delay(PAUSE_DIAGNOSTICS_DELAY_MS)
+            logPlaybackDiagnostics("pausedFor7s")
+        }
+    }
+
+    private fun logPlaybackDiagnostics(reason: String) {
+        updatePosition()
+        updateDuration()
+        Logger.info(
+            TAG,
+            "Playback diagnostics reason=$reason state=${player.playbackState} isPlaying=${player.isPlaying} playWhenReady=${player.playWhenReady} " +
+                "isLoading=${player.isLoading} hasRenderedFirstFrame=$hasRenderedFirstFrame positionMs=$position durationMs=$duration " +
+                "videoSize=${player.videoSize.width}x${player.videoSize.height} unappliedRotation=${player.videoSize.unappliedRotationDegrees}",
+        )
+    }
+
+    private fun logVideoSize(videoSize: VideoSize) {
+        Logger.info(
+            TAG,
+            "Video size changed width=${videoSize.width} height=${videoSize.height} unappliedRotation=${videoSize.unappliedRotationDegrees} pixelRatio=${videoSize.pixelWidthHeightRatio}",
+        )
+    }
+
+    private fun logPlayerError(error: PlaybackException?) {
+        if (error == null) return
+        Logger.error(TAG, "Player error code=${error.errorCode} name=${error.errorCodeName}", error)
+    }
+
+    private companion object {
+        private const val TAG = "MediaPresentationState"
+        private const val PAUSE_DIAGNOSTICS_DELAY_MS = 7_000L
+    }
+}
+
+val MediaPresentationState.positionFormatted: String
+    get() = position.milliseconds.formatted()
+
+val MediaPresentationState.durationFormatted: String
+    get() = duration.milliseconds.formatted()
+
+val MediaPresentationState.pendingPositionFormatted: String
+    get() = (duration - position).milliseconds.formatted()
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/MetadataState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/MetadataState.kt
new file mode 100644
index 000000000..53d85eac4
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/MetadataState.kt
@@ -0,0 +1,51 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.isVideoEffectsAvailable
+
+@Composable
+fun rememberMetadataState(player: Player): MetadataState {
+    val metadataState = remember { MetadataState(player) }
+    LaunchedEffect(player) { metadataState.observe() }
+    return metadataState
+}
+
+@Stable
+class MetadataState(private val player: Player) {
+    var title: String? by mutableStateOf(null)
+        private set
+
+    var artworkData: ByteArray? by mutableStateOf(null)
+        private set
+
+    var isVideoEffectsAvailable: Boolean by mutableStateOf(true)
+        private set
+
+    suspend fun observe() {
+        updateFromPlayer()
+        player.listen { events ->
+            if (events.containsAny(
+                    Player.EVENT_MEDIA_METADATA_CHANGED,
+                    Player.EVENT_MEDIA_ITEM_TRANSITION,
+                    Player.EVENT_TIMELINE_CHANGED,
+                )
+            ) {
+                updateFromPlayer()
+            }
+        }
+    }
+
+    private fun updateFromPlayer() {
+        title = player.mediaMetadata.title?.toString()
+        artworkData = player.mediaMetadata.artworkData
+        isVideoEffectsAvailable = player.mediaMetadata.isVideoEffectsAvailable
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/PictureInPictureState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/PictureInPictureState.kt
new file mode 100644
index 000000000..8bd4c1151
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/PictureInPictureState.kt
@@ -0,0 +1,259 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import android.app.AppOpsManager
+import android.app.PendingIntent
+import android.app.PictureInPictureParams
+import android.app.RemoteAction
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.graphics.Rect
+import android.graphics.drawable.Icon
+import android.os.Build
+import android.os.Process
+import android.util.Rational
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.LocalActivity
+import androidx.annotation.DrawableRes
+import androidx.annotation.RequiresApi
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.DisposableEffectResult
+import androidx.compose.runtime.DisposableEffectScope
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.core.app.PictureInPictureModeChangedInfo
+import androidx.core.content.ContextCompat
+import androidx.core.content.ContextCompat.getSystemService
+import androidx.core.net.toUri
+import androidx.core.util.Consumer
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.isPipFeatureSupported
+import app.gyrolet.mpvrx.R
+
+@Composable
+fun rememberPictureInPictureState(
+    player: Player,
+    shouldAutoEnter: Boolean = true,
+): PictureInPictureState {
+    val activity = LocalActivity.current
+    val pictureInPictureState = remember {
+        PictureInPictureState(
+            player = player,
+            activity = activity as ComponentActivity,
+            shouldAutoEnter = shouldAutoEnter,
+        )
+    }
+    DisposableEffect(activity) { pictureInPictureState.handleListeners(this) }
+    LaunchedEffect(player) { pictureInPictureState.observe() }
+    return pictureInPictureState
+}
+
+@Stable
+class PictureInPictureState(
+    private val player: Player,
+    private val activity: ComponentActivity,
+    private val shouldAutoEnter: Boolean = true,
+) {
+    companion object {
+        private const val PIP_INTENT_ACTION = "pip_action"
+        private const val PIP_INTENT_ACTION_CODE = "pip_action_code"
+        private const val PIP_ACTION_PLAY = 1
+        private const val PIP_ACTION_PAUSE = 2
+        private const val PIP_ACTION_NEXT = 3
+        private const val PIP_ACTION_PREVIOUS = 4
+    }
+
+    val isPipSupported: Boolean = activity.isPipFeatureSupported
+
+    val hasPipPermission: Boolean
+        get() = if (isPipSupported) {
+            val appOps = getSystemService(activity, AppOpsManager::class.java) ?: return true
+            appOps.checkOpNoThrow(AppOpsManager.OPSTR_PICTURE_IN_PICTURE, Process.myUid(), activity.packageName) == AppOpsManager.MODE_ALLOWED
+        } else {
+            true
+        }
+
+    var isInPictureInPictureMode: Boolean by mutableStateOf(false)
+        private set
+    var videoViewRect: Rect? by mutableStateOf(null)
+        private set
+
+    private val pictureInPictureParamsBuilder = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        PictureInPictureParams.Builder().apply {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                setSeamlessResizeEnabled(true)
+            }
+        }
+    } else {
+        null
+    }
+
+    private var lastAppliedAspectRatio: Rational? = null
+
+    fun updateVideoViewRect(rect: Rect) {
+        val resolvedRect = Rect(rect)
+        if (videoViewRect == resolvedRect) return
+
+        videoViewRect = resolvedRect
+        if (pictureInPictureParamsBuilder == null) return
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        if (resolvedRect.width() <= 0 || resolvedRect.height() <= 0) return
+
+        val aspectRatio = Rational(resolvedRect.width(), resolvedRect.height())
+            .takeIf { it.toFloat() in 0.5f..2.39f }
+        if (aspectRatio == lastAppliedAspectRatio) return
+        lastAppliedAspectRatio = aspectRatio
+
+        if (aspectRatio != null) {
+            pictureInPictureParamsBuilder.setAspectRatio(aspectRatio)
+        }
+        pictureInPictureParamsBuilder.setSourceRectHint(resolvedRect)
+        val params = pictureInPictureParamsBuilder.build()
+        runCatching { activity.setPictureInPictureParams(params) }
+    }
+
+    fun enterPictureInPictureMode(): Boolean {
+        if (pictureInPictureParamsBuilder == null) return false
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false
+        if (isInPictureInPictureMode) return false
+
+        return activity.enterPictureInPictureMode(pictureInPictureParamsBuilder.build())
+    }
+
+    fun openPictureInPictureSettings() {
+        val intent = Intent("android.settings.PICTURE_IN_PICTURE_SETTINGS").apply {
+            data = "package:${activity.packageName}".toUri()
+        }
+        activity.startActivity(intent)
+    }
+
+    fun handleListeners(disposableEffectScope: DisposableEffectScope): DisposableEffectResult = with(disposableEffectScope) {
+        val pipBroadcastReceiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                if (intent == null || intent.action != PIP_INTENT_ACTION) return
+                when (intent.getIntExtra(PIP_INTENT_ACTION_CODE, 0)) {
+                    PIP_ACTION_PLAY -> player.play()
+                    PIP_ACTION_PAUSE -> player.pause()
+                    PIP_ACTION_NEXT -> player.seekToNext()
+                    PIP_ACTION_PREVIOUS -> player.seekToPrevious()
+                }
+            }
+        }
+
+        val pictureInPictureModeChangedListener: Consumer<PictureInPictureModeChangedInfo> = Consumer {
+            updateIsInPictureInPictureMode(pipBroadcastReceiver)
+        }
+
+        updateIsInPictureInPictureMode(pipBroadcastReceiver)
+        activity.addOnPictureInPictureModeChangedListener(pictureInPictureModeChangedListener)
+
+        return onDispose {
+            runCatching { activity.unregisterReceiver(pipBroadcastReceiver) }
+            activity.removeOnPictureInPictureModeChangedListener(pictureInPictureModeChangedListener)
+        }
+    }
+
+    suspend fun observe() {
+        updateAutoEnterEnabled()
+        updatePictureInPictureActions()
+
+        player.listen { events ->
+            if (events.contains(Player.EVENT_IS_PLAYING_CHANGED)) {
+                updateAutoEnterEnabled()
+                updatePictureInPictureActions()
+            }
+        }
+    }
+
+    private fun updateIsInPictureInPictureMode(pipBroadcastReceiver: BroadcastReceiver) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+
+        isInPictureInPictureMode = activity.isInPictureInPictureMode
+        if (isInPictureInPictureMode) {
+            ContextCompat.registerReceiver(
+                activity,
+                pipBroadcastReceiver,
+                IntentFilter(PIP_INTENT_ACTION),
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) ContextCompat.RECEIVER_NOT_EXPORTED else 0,
+            )
+        } else {
+            runCatching { activity.unregisterReceiver(pipBroadcastReceiver) }
+        }
+    }
+
+    private fun updateAutoEnterEnabled() {
+        if (pictureInPictureParamsBuilder == null) return
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return
+
+        pictureInPictureParamsBuilder.setAutoEnterEnabled(shouldAutoEnter && player.isPlaying)
+        val params = pictureInPictureParamsBuilder.build()
+        runCatching { activity.setPictureInPictureParams(params) }
+    }
+
+    private fun updatePictureInPictureActions() {
+        if (pictureInPictureParamsBuilder == null) return
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+
+        val actions = listOf(
+            createPipAction(
+                context = activity,
+                title = "skip to previous",
+                icon = R.drawable.ic_skip_prev,
+                actionCode = PIP_ACTION_PREVIOUS,
+            ),
+            if (player.isPlaying) {
+                createPipAction(
+                    context = activity,
+                    title = "pause",
+                    icon = R.drawable.ic_pause,
+                    actionCode = PIP_ACTION_PAUSE,
+                )
+            } else {
+                createPipAction(
+                    context = activity,
+                    title = "play",
+                    icon = R.drawable.ic_play,
+                    actionCode = PIP_ACTION_PLAY,
+                )
+            },
+            createPipAction(
+                context = activity,
+                title = "skip to next",
+                icon = R.drawable.ic_skip_next,
+                actionCode = PIP_ACTION_NEXT,
+            ),
+        )
+
+        pictureInPictureParamsBuilder.setActions(actions)
+        val params = pictureInPictureParamsBuilder.build()
+        runCatching { activity.setPictureInPictureParams(params) }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun createPipAction(
+        context: Context,
+        title: String,
+        @DrawableRes icon: Int,
+        actionCode: Int,
+    ): RemoteAction = RemoteAction(
+        Icon.createWithResource(context, icon),
+        title,
+        title,
+        PendingIntent.getBroadcast(
+            context,
+            actionCode,
+            Intent(PIP_INTENT_ACTION).apply {
+                putExtra(PIP_INTENT_ACTION_CODE, actionCode)
+                setPackage(context.packageName)
+            },
+            PendingIntent.FLAG_IMMUTABLE,
+        ),
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/PlaybackParametersState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/PlaybackParametersState.kt
new file mode 100644
index 000000000..0eeeba014
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/PlaybackParametersState.kt
@@ -0,0 +1,84 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.session.MediaController
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.isSkipSilenceEnabled
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.setSkipSilenceEnabled
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.setTransientPlaybackSpeed
+
+@UnstableApi
+@Composable
+fun rememberPlaybackParametersState(player: Player): PlaybackParametersState {
+    val scope = rememberCoroutineScope()
+    val playbackParametersState = remember { PlaybackParametersState(player, scope) }
+    LaunchedEffect(player) { playbackParametersState.observe() }
+    return playbackParametersState
+}
+
+@UnstableApi
+class PlaybackParametersState(
+    private val player: Player,
+    private val scope: CoroutineScope,
+) {
+    var speed: Float by mutableFloatStateOf(1f)
+        private set
+
+    var isSkipSilenceEnabled: Boolean by mutableStateOf(false)
+        private set
+
+    fun setPlaybackSpeed(speed: Float) {
+        when (player) {
+            is MediaController -> player.setTransientPlaybackSpeed(speed)
+            else -> player.setPlaybackSpeed(speed)
+        }
+    }
+
+    fun setIsSkipSilenceEnabled(isEnabled: Boolean) {
+        scope.launch {
+            when (player) {
+                is MediaController -> player.setSkipSilenceEnabled(isEnabled)
+                is ExoPlayer -> player.skipSilenceEnabled = isEnabled
+                else -> return@launch
+            }
+            updateSkipSilenceEnabled()
+        }
+    }
+
+    suspend fun observe() {
+        updateSpeed()
+        updateSkipSilenceEnabled()
+
+        player.listen { events ->
+            if (events.contains(Player.EVENT_PLAYBACK_PARAMETERS_CHANGED)) {
+                updateSpeed()
+            }
+        }
+    }
+
+    private fun updateSpeed() {
+        speed = player.playbackParameters.speed
+    }
+
+    private fun updateSkipSilenceEnabled() {
+        scope.launch {
+            isSkipSilenceEnabled = when (player) {
+                is MediaController -> player.isSkipSilenceEnabled()
+                is ExoPlayer -> player.skipSilenceEnabled
+                else -> return@launch
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/PlaylistState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/PlaylistState.kt
new file mode 100644
index 000000000..c81363ed1
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/PlaylistState.kt
@@ -0,0 +1,77 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import androidx.media3.common.util.UnstableApi
+
+@UnstableApi
+@Composable
+fun rememberPlaylistState(player: Player): PlaylistState {
+    val playlistState = remember { PlaylistState(player) }
+    LaunchedEffect(player) { playlistState.observe() }
+    return playlistState
+}
+
+class PlaylistState(
+    private val player: Player,
+) {
+    var playlist: List<MediaItem> by mutableStateOf(emptyList())
+        private set
+
+    var currentMediaItemIndex: Int by mutableStateOf(0)
+        private set
+
+    suspend fun observe() {
+        updatePlaylist()
+        updateCurrentIndex()
+
+        player.listen { events ->
+            if (events.containsAny(Player.EVENT_MEDIA_ITEM_TRANSITION, Player.EVENT_TIMELINE_CHANGED)) {
+                updatePlaylist()
+            }
+            if (events.contains(Player.EVENT_MEDIA_ITEM_TRANSITION)) {
+                updateCurrentIndex()
+            }
+        }
+    }
+
+    fun moveItem(fromIndex: Int, toIndex: Int) {
+        if (fromIndex == toIndex) return
+        if (fromIndex !in playlist.indices || toIndex !in playlist.indices) return
+
+        player.moveMediaItem(fromIndex, toIndex)
+        updatePlaylist()
+        updateCurrentIndex()
+    }
+
+    fun removeItem(index: Int) {
+        if (index !in playlist.indices) return
+        if (playlist.size <= 1) return // 不允许删除最后一项
+
+        player.removeMediaItem(index)
+        updatePlaylist()
+        updateCurrentIndex()
+    }
+
+    fun seekToItem(index: Int) {
+        if (index !in playlist.indices) return
+        player.seekToDefaultPosition(index)
+        updateCurrentIndex()
+    }
+
+    private fun updatePlaylist() {
+        val items = (0 until player.mediaItemCount).map { player.getMediaItemAt(it) }
+        playlist = items
+    }
+
+    private fun updateCurrentIndex() {
+        currentMediaItemIndex = player.currentMediaItemIndex
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/RotationState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/RotationState.kt
new file mode 100644
index 000000000..c786c3978
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/RotationState.kt
@@ -0,0 +1,161 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import android.content.pm.ActivityInfo
+import android.content.res.Configuration
+import android.util.Log
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.LocalActivity
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.DisposableEffectResult
+import androidx.compose.runtime.DisposableEffectScope
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.core.util.Consumer
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import androidx.media3.common.util.UnstableApi
+import app.gyrolet.mpvrx.exoplayer.core.model.LastPlayerScreenOrientation
+import app.gyrolet.mpvrx.exoplayer.core.model.ScreenOrientation
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.toActivityOrientation
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.videoHeight
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.videoRotation
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.videoWidth
+
+@UnstableApi
+@Composable
+fun rememberRotationState(
+    player: Player,
+    screenOrientation: ScreenOrientation,
+    shouldRememberScreenOrientation: Boolean,
+    lastScreenOrientation: LastPlayerScreenOrientation?,
+    onLastScreenOrientationChange: (LastPlayerScreenOrientation) -> Unit,
+): RotationState {
+    val activity = LocalActivity.current as ComponentActivity
+    val rotationState = remember(screenOrientation, shouldRememberScreenOrientation, lastScreenOrientation) {
+        RotationState(
+            activity = activity,
+            screenOrientation = screenOrientation,
+            shouldRememberScreenOrientation = shouldRememberScreenOrientation,
+            lastScreenOrientation = lastScreenOrientation,
+            onLastScreenOrientationChange = onLastScreenOrientationChange,
+        )
+    }
+    DisposableEffect(activity, rotationState) {
+        rotationState.handleListeners(this)
+    }
+    LaunchedEffect(player, rotationState) { rotationState.observe(player) }
+    return rotationState
+}
+
+@Stable
+class RotationState(
+    private val activity: ComponentActivity,
+    private val screenOrientation: ScreenOrientation,
+    private val shouldRememberScreenOrientation: Boolean,
+    private val lastScreenOrientation: LastPlayerScreenOrientation?,
+    private val onLastScreenOrientationChange: (LastPlayerScreenOrientation) -> Unit,
+) {
+    var currentRequestedOrientation: Int by mutableIntStateOf(activity.requestedOrientation)
+        private set
+
+    fun rotate() {
+        val newOrientation = when (activity.resources.configuration.orientation) {
+            Configuration.ORIENTATION_LANDSCAPE -> LastPlayerScreenOrientation.PORTRAIT
+            else -> LastPlayerScreenOrientation.LANDSCAPE
+        }
+        activity.requestedOrientation = newOrientation.toActivityOrientation()
+        if (shouldRememberScreenOrientation) {
+            onLastScreenOrientationChange(newOrientation)
+        }
+    }
+
+    fun handleListeners(disposableEffectScope: DisposableEffectScope): DisposableEffectResult = with(disposableEffectScope) {
+        val configurationChangedListener: Consumer<Configuration> = Consumer {
+            currentRequestedOrientation = activity.requestedOrientation
+        }
+
+        activity.addOnConfigurationChangedListener(configurationChangedListener)
+
+        onDispose {
+            activity.removeOnConfigurationChangedListener(configurationChangedListener)
+        }
+    }
+
+    suspend fun observe(player: Player) {
+        Log.d(TAG, "observe: player=${player.javaClass.simpleName}@${System.identityHashCode(player)}")
+        setOrientation(player)
+        maybeApplyVideoOrientation(player)
+
+        // 视频尺寸通过 metadata extras 从 Service 端传递
+        player.listen { events ->
+            if (events.containsAny(
+                    Player.EVENT_MEDIA_METADATA_CHANGED,
+                    Player.EVENT_MEDIA_ITEM_TRANSITION,
+                )
+            ) {
+                val metadata = player.mediaMetadata
+                Log.d(TAG, "listen: w=${metadata.videoWidth}, h=${metadata.videoHeight}, rot=${metadata.videoRotation}")
+                maybeApplyVideoOrientation(player)
+            }
+        }
+    }
+
+    private fun maybeApplyVideoOrientation(player: Player) {
+        if (screenOrientation != ScreenOrientation.VIDEO_ORIENTATION) return
+        if (shouldRememberScreenOrientation && lastScreenOrientation != null) return
+        val orientation = getVideoBasedOrientation(player)
+        if (orientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
+            Log.d(TAG, "applyOrientation: $orientation")
+            activity.requestedOrientation = orientation
+        }
+    }
+
+    private fun setOrientation(player: Player) {
+        Log.d(TAG, "setOrientation: requestedOrientation=${activity.requestedOrientation}")
+        if (activity.requestedOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) return
+
+        activity.requestedOrientation = lastScreenOrientation
+            ?.takeIf { shouldRememberScreenOrientation }
+            ?.toActivityOrientation()
+            ?: when (screenOrientation) {
+                ScreenOrientation.AUTOMATIC -> ActivityInfo.SCREEN_ORIENTATION_SENSOR
+                ScreenOrientation.LANDSCAPE -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+                ScreenOrientation.LANDSCAPE_REVERSE -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
+                ScreenOrientation.LANDSCAPE_AUTO -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+                ScreenOrientation.PORTRAIT -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
+                ScreenOrientation.VIDEO_ORIENTATION -> getVideoBasedOrientation(player)
+            }
+    }
+
+    private fun getVideoBasedOrientation(player: Player): Int {
+        val metadata = player.mediaMetadata
+        val width = metadata.videoWidth ?: 0
+        val height = metadata.videoHeight ?: 0
+        if (width == 0 || height == 0) {
+            Log.d(TAG, "getVideoBasedOrientation: metadata=${width}x$height -> UNSPECIFIED")
+            return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+        }
+
+        val rotation = metadata.videoRotation ?: 0
+
+        val visuallyPortrait = if (rotation == 90 || rotation == 270) {
+            width >= height
+        } else {
+            height >= width
+        }
+
+        Log.d(TAG, "getVideoBasedOrientation: ${width}x$height, rotation=$rotation, portrait=$visuallyPortrait")
+        return if (visuallyPortrait) {
+            ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
+        } else {
+            ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+        }
+    }
+}
+
+private const val TAG = "RotationState"
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/SeekGestureState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/SeekGestureState.kt
new file mode 100644
index 000000000..f7c23a17c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/SeekGestureState.kt
@@ -0,0 +1,154 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.annotation.OptIn
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.pointer.PointerInputChange
+import androidx.media3.common.C
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import kotlin.math.abs
+import kotlin.time.Duration.Companion.milliseconds
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.availableDurationMs
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.formatted
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.seekToRequestedPosition
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.setIsScrubbingModeEnabled
+
+@UnstableApi
+@Composable
+fun rememberSeekGestureState(
+    player: Player,
+    sensitivity: Float = 0.5f,
+    isSeekGestureEnabled: Boolean,
+): SeekGestureState {
+    val seekGestureState = remember {
+        SeekGestureState(
+            player = player,
+            sensitivity = sensitivity,
+            isSeekGestureEnabled = isSeekGestureEnabled,
+        )
+    }
+    return seekGestureState
+}
+
+@Stable
+class SeekGestureState(
+    private val player: Player,
+    private val isSeekGestureEnabled: Boolean = true,
+    private val sensitivity: Float = 0.5f,
+) {
+    var isSeeking: Boolean by mutableStateOf(false)
+        private set
+
+    var seekStartPosition: Long? by mutableStateOf(null)
+        private set
+
+    var seekAmount: Long? by mutableStateOf(null)
+        private set
+
+    var pendingSeekPosition: Long? by mutableStateOf(null)
+        private set
+
+    private var seekStartX = 0f
+
+    fun onSeek(value: Long) {
+        val duration = player.availableDurationMs()
+        if (duration == C.TIME_UNSET || duration <= 0L) return
+        val currentPosition = player.currentPosition.takeIf { it != C.TIME_UNSET } ?: 0L
+
+        if (!isSeeking) {
+            isSeeking = true
+            seekStartPosition = currentPosition
+            pendingSeekPosition = currentPosition
+            player.setIsScrubbingModeEnabled(true)
+        }
+
+        val newPosition = value.coerceIn(0L, duration)
+        pendingSeekPosition = newPosition
+        seekAmount = (newPosition - seekStartPosition!!).coerceIn(
+            minimumValue = 0 - seekStartPosition!!,
+            maximumValue = duration - seekStartPosition!!,
+        )
+    }
+
+    fun onSeekEnd() {
+        commitPendingSeek()
+        reset()
+    }
+
+    fun onDragStart(offset: Offset) {
+        if (!isSeekGestureEnabled) return
+        val duration = player.availableDurationMs()
+        if (duration == C.TIME_UNSET || duration <= 0L) return
+        val currentPosition = player.currentPosition.takeIf { it != C.TIME_UNSET } ?: 0L
+
+        isSeeking = true
+        seekStartX = offset.x
+        seekStartPosition = currentPosition
+        pendingSeekPosition = currentPosition
+
+        player.setIsScrubbingModeEnabled(true)
+    }
+
+    @OptIn(UnstableApi::class)
+    fun onDrag(change: PointerInputChange, dragAmount: Float) {
+        val seekStartPosition = seekStartPosition ?: return
+        val duration = player.availableDurationMs()
+        if (duration == C.TIME_UNSET) return
+        if (change.isConsumed) return
+
+        val currentPreviewPosition = pendingSeekPosition ?: seekStartPosition
+        if (currentPreviewPosition <= 0L && dragAmount < 0) return
+        if (currentPreviewPosition >= duration && dragAmount > 0) return
+
+        val newPosition = (seekStartPosition + ((change.position.x - seekStartX) * (sensitivity * 100)).toInt())
+            .coerceIn(0L, duration)
+        pendingSeekPosition = newPosition
+        seekAmount = (newPosition - seekStartPosition).coerceIn(
+            minimumValue = 0 - seekStartPosition,
+            maximumValue = duration - seekStartPosition,
+        )
+    }
+
+    fun onDragEnd() {
+        commitPendingSeek()
+        reset()
+    }
+
+    private fun commitPendingSeek() {
+        val pendingSeekPosition = pendingSeekPosition ?: return
+        val currentPosition = player.currentPosition.takeIf { it != C.TIME_UNSET }
+        if (currentPosition == null || currentPosition != pendingSeekPosition) {
+            player.seekToRequestedPosition(pendingSeekPosition)
+        }
+    }
+
+    private fun reset() {
+        player.setIsScrubbingModeEnabled(false)
+        isSeeking = false
+        seekStartPosition = null
+        seekAmount = null
+        pendingSeekPosition = null
+
+        seekStartX = 0f
+    }
+}
+
+val SeekGestureState.seekAmountFormatted: String
+    get() {
+        val seekAmount = seekAmount ?: return ""
+        val sign = if (seekAmount < 0) "-" else "+"
+        return sign + abs(seekAmount).milliseconds.formatted()
+    }
+
+val SeekGestureState.seekToPositionFormated: String
+    get() {
+        val position = seekStartPosition ?: return ""
+        val seekAmount = seekAmount ?: return ""
+        return (position + seekAmount).milliseconds.formatted()
+    }
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/SleepTimerState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/SleepTimerState.kt
new file mode 100644
index 000000000..8b5d37bd0
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/SleepTimerState.kt
@@ -0,0 +1,98 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+@Composable
+fun rememberSleepTimerState(
+    player: Player,
+): SleepTimerState {
+    val scope = rememberCoroutineScope()
+    val state = remember { SleepTimerState(player, scope) }
+    return state
+}
+
+@Stable
+class SleepTimerState(
+    private val player: Player,
+    private val scope: CoroutineScope,
+) {
+    var remainingMillis: Long by mutableLongStateOf(0L)
+        private set
+
+    var isActive: Boolean by mutableStateOf(false)
+        private set
+
+    private var countdownJob: Job? = null
+    private var observeJob: Job? = null
+
+    fun start(durationMinutes: Int) {
+        countdownJob?.cancel()
+        remainingMillis = durationMinutes * 60_000L
+        isActive = true
+        startCountdown()
+        ensureObserving()
+    }
+
+    fun cancel() {
+        countdownJob?.cancel()
+        countdownJob = null
+        observeJob?.cancel()
+        observeJob = null
+        remainingMillis = 0L
+        isActive = false
+    }
+
+    private fun pauseCountdown() {
+        countdownJob?.cancel()
+        countdownJob = null
+    }
+
+    private fun resumeIfActive() {
+        if (isActive && remainingMillis > 0L) {
+            startCountdown()
+        }
+    }
+
+    // 通过 player.listen 观察播放状态变化，暂停时暂停倒计时
+    private fun ensureObserving() {
+        if (observeJob != null) return
+        observeJob = scope.launch {
+            player.listen { events ->
+                if (events.contains(Player.EVENT_IS_PLAYING_CHANGED)) {
+                    if (player.isPlaying) {
+                        resumeIfActive()
+                    } else {
+                        pauseCountdown()
+                    }
+                }
+            }
+        }
+    }
+
+    private fun startCountdown() {
+        countdownJob?.cancel()
+        countdownJob = scope.launch {
+            while (remainingMillis > 0L) {
+                delay(1000L)
+                remainingMillis = (remainingMillis - 1000L).coerceAtLeast(0L)
+            }
+            isActive = false
+            player.pause()
+            observeJob?.cancel()
+            observeJob = null
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/SubtitleOptionsState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/SubtitleOptionsState.kt
new file mode 100644
index 000000000..379c2a34e
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/SubtitleOptionsState.kt
@@ -0,0 +1,128 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.session.MediaController
+import io.github.anilbeesetti.nextlib.media3ext.renderer.subtitleDelayMilliseconds
+import io.github.anilbeesetti.nextlib.media3ext.renderer.subtitleSpeed
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.copy
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.getSubtitleDelayMilliseconds
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.getSubtitleSpeed
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.setSubtitleDelayMilliseconds
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.setSubtitleSpeed
+
+@UnstableApi
+@Composable
+fun rememberSubtitleOptionsState(
+    player: Player,
+    onEvent: (SubtitleOptionsEvent) -> Unit = {},
+): SubtitleOptionsState {
+    val scope = rememberCoroutineScope()
+    val subtitleOptionsState = remember { SubtitleOptionsState(player, scope, onEvent) }
+    LaunchedEffect(player) { subtitleOptionsState.observe() }
+    return subtitleOptionsState
+}
+
+@Stable
+class SubtitleOptionsState(
+    val player: Player,
+    val scope: CoroutineScope,
+    val onEvent: (SubtitleOptionsEvent) -> Unit = {},
+) {
+
+    var delayMilliseconds: Long by mutableLongStateOf(0L)
+        private set
+
+    var speedMultiplier: Float by mutableFloatStateOf(1f)
+        private set
+
+    fun setDelay(delayMillis: Long) {
+        scope.launch {
+            when (player) {
+                is MediaController -> player.setSubtitleDelayMilliseconds(delayMillis)
+                is ExoPlayer -> player.subtitleDelayMilliseconds = delayMillis
+                else -> return@launch
+            }
+            updateSubtitleDelayMilliseconds()
+            updateDelayMetadataAndSendEvent()
+        }
+    }
+
+    fun setSpeed(speed: Float) {
+        scope.launch {
+            when (player) {
+                is MediaController -> player.setSubtitleSpeed(speed)
+                is ExoPlayer -> player.subtitleSpeed = speed
+                else -> return@launch
+            }
+            updateSubtitleSpeed()
+            updateSpeedMetadataAndSendEvent()
+        }
+    }
+
+    suspend fun observe() {
+        updateSubtitleDelayMilliseconds()
+        updateSubtitleSpeed()
+        player.listen { events ->
+            if (events.containsAny(Player.EVENT_TRACKS_CHANGED, Player.EVENT_CUES)) {
+                scope.launch {
+                    updateSubtitleDelayMilliseconds()
+                    updateSubtitleSpeed()
+                }
+            }
+        }
+    }
+
+    private suspend fun updateSubtitleDelayMilliseconds() {
+        delayMilliseconds = when (player) {
+            is MediaController -> player.getSubtitleDelayMilliseconds()
+            is ExoPlayer -> player.subtitleDelayMilliseconds
+            else -> return
+        }
+    }
+
+    private suspend fun updateSubtitleSpeed() {
+        speedMultiplier = when (player) {
+            is MediaController -> player.getSubtitleSpeed()
+            is ExoPlayer -> player.subtitleSpeed
+            else -> return
+        }
+    }
+
+    private fun updateDelayMetadataAndSendEvent(delay: Long = this.delayMilliseconds) {
+        val currentMediaItem = player.currentMediaItem ?: return
+        player.replaceMediaItem(
+            player.currentMediaItemIndex,
+            currentMediaItem.copy(subtitleDelayMilliseconds = delay),
+        )
+        onEvent(SubtitleOptionsEvent.DelayChanged(currentMediaItem, delay))
+    }
+
+    private fun updateSpeedMetadataAndSendEvent(speed: Float = this.speedMultiplier) {
+        val currentMediaItem = player.currentMediaItem ?: return
+        player.replaceMediaItem(
+            player.currentMediaItemIndex,
+            currentMediaItem.copy(subtitleSpeed = speed),
+        )
+        onEvent(SubtitleOptionsEvent.SpeedChanged(currentMediaItem, speed))
+    }
+}
+
+sealed interface SubtitleOptionsEvent {
+    data class DelayChanged(val mediaItem: MediaItem, val delay: Long) : SubtitleOptionsEvent
+    data class SpeedChanged(val mediaItem: MediaItem, val speed: Float) : SubtitleOptionsEvent
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/TapGestureState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/TapGestureState.kt
new file mode 100644
index 000000000..5717f084b
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/TapGestureState.kt
@@ -0,0 +1,225 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.PressInteraction
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.unit.IntSize
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.MediaController
+import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.round
+import app.gyrolet.mpvrx.exoplayer.core.model.DoubleTapGesture
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.canSeekCurrentMediaItem
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.seekByRequestedOffset
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.setTransientPlaybackSpeed
+
+@UnstableApi
+@Composable
+fun rememberTapGestureState(
+    player: Player,
+    doubleTapGesture: DoubleTapGesture,
+    seekIncrementMillis: Long,
+    shouldUseLongPressGesture: Boolean,
+    shouldUseLongPressVariableSpeed: Boolean,
+    longPressSpeed: Float,
+): TapGestureState {
+    val coroutineScope = rememberCoroutineScope()
+    val tapGestureState = remember(
+        player,
+        doubleTapGesture,
+        seekIncrementMillis,
+        shouldUseLongPressGesture,
+        shouldUseLongPressVariableSpeed,
+        longPressSpeed,
+        coroutineScope,
+    ) {
+        TapGestureState(
+            player = player,
+            doubleTapGesture = doubleTapGesture,
+            seekIncrementMillis = seekIncrementMillis,
+            shouldUseLongPressGesture = shouldUseLongPressGesture,
+            shouldUseLongPressVariableSpeed = shouldUseLongPressVariableSpeed,
+            longPressSpeed = longPressSpeed,
+            coroutineScope = coroutineScope,
+        )
+    }
+    return tapGestureState
+}
+
+@Stable
+class TapGestureState(
+    private val player: Player,
+    private val seekIncrementMillis: Long,
+    private val shouldUseLongPressGesture: Boolean = true,
+    private val shouldUseLongPressVariableSpeed: Boolean = false,
+    private val coroutineScope: CoroutineScope,
+    val longPressSpeed: Float = PlayerPreferences.DEFAULT_LONG_PRESS_CONTROLS_SPEED,
+    val doubleTapGesture: DoubleTapGesture,
+    val interactionSource: MutableInteractionSource = MutableInteractionSource(),
+) {
+    var seekMillis by mutableLongStateOf(0L)
+    var isLongPressGestureInAction by mutableStateOf(false)
+    var currentLongPressSpeed by mutableFloatStateOf(longPressSpeed)
+        private set
+
+    val canUseLongPressVariableSpeed: Boolean
+        get() = shouldUseLongPressVariableSpeed && isLongPressGestureInAction
+    var isLongPressGestureCaptured: Boolean = false
+        private set
+    var longPressSpeedChangeCount by mutableIntStateOf(0)
+        private set
+
+    private var resetJob: Job? = null
+    private var originalPlaybackSpeed: Float = player.playbackParameters.speed
+    private var longPressDragAmount by mutableFloatStateOf(0f)
+
+    fun handleDoubleTap(offset: Offset, size: IntSize) {
+        if (!player.canSeekCurrentMediaItem()) return
+
+        val action = when (doubleTapGesture) {
+            DoubleTapGesture.FAST_FORWARD_AND_REWIND -> {
+                val viewCenterX = size.width / 2
+                when {
+                    offset.x < viewCenterX -> DoubleTapAction.SEEK_BACKWARD
+                    else -> DoubleTapAction.SEEK_FORWARD
+                }
+            }
+
+            DoubleTapGesture.BOTH -> {
+                val eventPositionX = offset.x / size.width
+                when {
+                    eventPositionX < 0.35 -> DoubleTapAction.SEEK_BACKWARD
+                    eventPositionX > 0.65 -> DoubleTapAction.SEEK_FORWARD
+                    else -> DoubleTapAction.PLAY_PAUSE
+                }
+            }
+
+            DoubleTapGesture.PLAY_PAUSE -> DoubleTapAction.PLAY_PAUSE
+
+            DoubleTapGesture.NONE -> return
+        }
+
+        when (action) {
+            DoubleTapAction.SEEK_BACKWARD -> {
+                player.seekByRequestedOffset(-seekIncrementMillis)
+                if (seekMillis > 0L) {
+                    seekMillis = 0L
+                }
+                seekMillis -= seekIncrementMillis
+                interactionSource.tryEmit(PressInteraction.Press(offset))
+            }
+
+            DoubleTapAction.SEEK_FORWARD -> {
+                player.seekByRequestedOffset(seekIncrementMillis)
+                if (seekMillis < 0L) {
+                    seekMillis = 0L
+                }
+                seekMillis += seekIncrementMillis
+                interactionSource.tryEmit(PressInteraction.Press(offset))
+            }
+
+            DoubleTapAction.PLAY_PAUSE -> {
+                when (player.isPlaying) {
+                    true -> player.pause()
+                    false -> player.play()
+                }
+            }
+        }
+        resetDoubleTapSeekState()
+    }
+
+    fun handleLongPress() {
+        startTemporaryPlaybackSpeed(force = false)
+    }
+
+    fun handleKeyboardLongPress(): Boolean = startTemporaryPlaybackSpeed(force = true)
+
+    private fun startTemporaryPlaybackSpeed(force: Boolean): Boolean {
+        if (!force && !shouldUseLongPressGesture) return false
+        if (!player.isPlaying) return false
+        if (isLongPressGestureInAction) return false
+
+        isLongPressGestureCaptured = true
+        isLongPressGestureInAction = true
+        originalPlaybackSpeed = player.playbackParameters.speed
+        longPressDragAmount = 0f
+        currentLongPressSpeed = longPressSpeed
+        player.setPlaybackSpeedWithoutPersistence(currentLongPressSpeed)
+        return true
+    }
+
+    fun handleLongPressHorizontalDrag(dragAmount: Float) {
+        if (!canUseLongPressVariableSpeed) return
+
+        longPressDragAmount += dragAmount
+        val resolvedSpeed = resolveLongPressVariableSpeed(
+            baseSpeed = longPressSpeed,
+            accumulatedDragAmount = longPressDragAmount,
+        )
+        if (resolvedSpeed == currentLongPressSpeed) return
+
+        currentLongPressSpeed = resolvedSpeed
+        longPressSpeedChangeCount += 1
+        player.setPlaybackSpeedWithoutPersistence(currentLongPressSpeed)
+    }
+
+    fun handleOnLongPressRelease() {
+        if (!isLongPressGestureInAction) return
+
+        isLongPressGestureCaptured = false
+        isLongPressGestureInAction = false
+        longPressDragAmount = 0f
+        currentLongPressSpeed = longPressSpeed
+        player.setPlaybackSpeedWithoutPersistence(originalPlaybackSpeed)
+    }
+
+    private fun Player.setPlaybackSpeedWithoutPersistence(speed: Float) {
+        when (this) {
+            is MediaController -> setTransientPlaybackSpeed(speed)
+            else -> setPlaybackSpeed(speed)
+        }
+    }
+
+    private fun resetDoubleTapSeekState() {
+        resetJob?.cancel()
+        resetJob = coroutineScope.launch {
+            delay(750.milliseconds)
+            seekMillis = 0L
+        }
+    }
+}
+
+internal fun resolveLongPressVariableSpeed(
+    baseSpeed: Float,
+    accumulatedDragAmount: Float,
+    minSpeed: Float = PlayerPreferences.MIN_LONG_PRESS_CONTROLS_SPEED,
+    maxSpeed: Float = PlayerPreferences.MAX_LONG_PRESS_CONTROLS_SPEED,
+    pixelsPerStep: Float = 48f,
+): Float {
+    val speedDelta = (accumulatedDragAmount / pixelsPerStep) * 0.1f
+    return (baseSpeed + speedDelta)
+        .coerceIn(minSpeed, maxSpeed)
+        .round(1)
+}
+
+enum class DoubleTapAction {
+    SEEK_BACKWARD,
+    SEEK_FORWARD,
+    PLAY_PAUSE,
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/TracksState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/TracksState.kt
new file mode 100644
index 000000000..d122b270d
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/TracksState.kt
@@ -0,0 +1,51 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.media3.common.C
+import androidx.media3.common.Player
+import androidx.media3.common.Tracks
+import androidx.media3.common.listen
+import androidx.media3.common.util.UnstableApi
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.switchTrack
+
+@UnstableApi
+@Composable
+fun rememberTracksState(
+    player: Player,
+    trackType: @C.TrackType Int,
+): TracksState {
+    val tracksState = remember { TracksState(player, trackType) }
+    LaunchedEffect(player) { tracksState.observe() }
+    return tracksState
+}
+
+class TracksState(
+    private val player: Player,
+    private val trackType: @C.TrackType Int,
+) {
+    var tracks: List<Tracks.Group> by mutableStateOf(emptyList())
+        private set
+
+    fun switchTrack(index: Int) {
+        player.switchTrack(trackType, index)
+    }
+
+    suspend fun observe() {
+        updateTracks()
+
+        player.listen { events ->
+            if (events.contains(Player.EVENT_TRACKS_CHANGED)) {
+                updateTracks()
+            }
+        }
+    }
+
+    private fun updateTracks() {
+        tracks = player.currentTracks.groups.filter { it.type == trackType && it.isSupported }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/VideoZoomAndContentScaleState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/VideoZoomAndContentScaleState.kt
new file mode 100644
index 000000000..aad299989
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/VideoZoomAndContentScaleState.kt
@@ -0,0 +1,190 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.unit.Constraints
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import androidx.media3.common.util.UnstableApi
+import kotlin.math.abs
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.model.VideoContentScale
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.copy
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.next
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.videoHeight
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.videoRotation
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.videoWidth
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.videoZoom
+
+@UnstableApi
+@Composable
+fun rememberVideoZoomAndContentScaleState(
+    player: Player,
+    initialContentScale: VideoContentScale,
+    isZoomGestureEnabled: Boolean,
+    isPanGestureEnabled: Boolean,
+    onEvent: (VideoZoomEvent) -> Unit = {},
+): VideoZoomAndContentScaleState {
+    val coroutineScope = rememberCoroutineScope()
+    val videoZoomAndContentScaleState = remember {
+        VideoZoomAndContentScaleState(
+            player = player,
+            initialContentScale = initialContentScale,
+            isZoomGestureEnabled = isZoomGestureEnabled,
+            isPanGestureEnabled = isPanGestureEnabled,
+            onEvent = onEvent,
+            coroutineScope = coroutineScope,
+        )
+    }
+    LaunchedEffect(player) { videoZoomAndContentScaleState.observe() }
+    return videoZoomAndContentScaleState
+}
+
+@Stable
+class VideoZoomAndContentScaleState(
+    private val player: Player,
+    initialContentScale: VideoContentScale,
+    private val isZoomGestureEnabled: Boolean = true,
+    private val isPanGestureEnabled: Boolean = true,
+    private val onEvent: (VideoZoomEvent) -> Unit,
+    private val coroutineScope: CoroutineScope,
+) {
+    companion object Companion {
+        private const val TAG = "VideoZoomAndContentScaleState"
+        private const val MIN_ZOOM = 0.25f
+        private const val MAX_ZOOM = 4f
+        private const val CONTENT_SCALE_INDICATOR_DURATION_MS = 1000L
+    }
+
+    var videoContentScale: VideoContentScale by mutableStateOf(initialContentScale)
+        private set
+
+    var zoom: Float by mutableFloatStateOf(1f)
+        private set
+
+    var offset: Offset by mutableStateOf(Offset.Zero)
+        private set
+
+    var isZooming: Boolean by mutableStateOf(false)
+        private set
+
+    var shouldShowContentScaleIndicator: Boolean by mutableStateOf(false)
+        private set
+
+    // 从 metadata extras 追踪视频尺寸，用于 resizeWithContentScale 的后备值
+    var metadataVideoWidth: Int by mutableIntStateOf(0)
+        private set
+    var metadataVideoHeight: Int by mutableIntStateOf(0)
+        private set
+    var metadataVideoRotation: Int by mutableIntStateOf(0)
+        private set
+
+    private var showContentScaleJob: Job? = null
+
+    fun onVideoContentScaleChanged(newContentScale: VideoContentScale) {
+        val previousContentScale = videoContentScale
+        videoContentScale = newContentScale
+        zoom = 1f
+        offset = Offset.Zero
+        Logger.info(
+            TAG,
+            "Video content scale changed from=$previousContentScale to=$newContentScale metadataVideo=${metadataVideoWidth}x$metadataVideoHeight rotation=$metadataVideoRotation",
+        )
+        onEvent(VideoZoomEvent.ContentScaleChanged(videoContentScale))
+        updateVideoScaleMetadataAndSendEvent()
+        shouldShowContentScaleIndicator()
+    }
+
+    private fun shouldShowContentScaleIndicator() {
+        showContentScaleJob?.cancel()
+        shouldShowContentScaleIndicator = true
+        showContentScaleJob = coroutineScope.launch {
+            delay(CONTENT_SCALE_INDICATOR_DURATION_MS)
+            shouldShowContentScaleIndicator = false
+            showContentScaleJob = null
+        }
+    }
+
+    fun switchToNextVideoContentScale() {
+        onVideoContentScaleChanged(videoContentScale.next())
+    }
+
+    fun onZoomPanGesture(constraints: Constraints, panChange: Offset, zoomChange: Float) {
+        if (player.duration == C.TIME_UNSET) return
+        if (!isZoomGestureEnabled) return
+
+        isZooming = true
+        zoom = (zoom * zoomChange).coerceIn(MIN_ZOOM, MAX_ZOOM)
+
+        val extraWidth = (zoom - 1) * constraints.maxWidth
+        val extraHeight = (zoom - 1) * constraints.maxHeight
+
+        val maxX = abs(extraWidth / 2)
+        val maxY = abs(extraHeight / 2)
+
+        if (isPanGestureEnabled) {
+            offset = Offset(
+                x = (offset.x + zoom * panChange.x).coerceIn(-maxX, maxX),
+                y = (offset.y + zoom * panChange.y).coerceIn(-maxY, maxY),
+            )
+        }
+    }
+
+    fun onZoomPanGestureEnd() {
+        isZooming = false
+        updateVideoScaleMetadataAndSendEvent()
+    }
+
+    suspend fun observe() {
+        updateFromMetadata()
+        zoom = player.currentMediaItem?.mediaMetadata?.videoZoom ?: 1f
+        player.listen { events ->
+            if (events.contains(Player.EVENT_MEDIA_METADATA_CHANGED)) {
+                updateFromMetadata()
+                zoom = player.currentMediaItem?.mediaMetadata?.videoZoom ?: 1f
+            }
+        }
+    }
+
+    private fun updateFromMetadata() {
+        val metadata = player.currentMediaItem?.mediaMetadata ?: return
+        val previousVideoWidth = metadataVideoWidth
+        val previousVideoHeight = metadataVideoHeight
+        val previousVideoRotation = metadataVideoRotation
+        metadataVideoWidth = metadata.videoWidth ?: 0
+        metadataVideoHeight = metadata.videoHeight ?: 0
+        metadataVideoRotation = metadata.videoRotation ?: 0
+        if (previousVideoWidth == metadataVideoWidth && previousVideoHeight == metadataVideoHeight && previousVideoRotation == metadataVideoRotation) return
+
+        Logger.info(TAG, "Video metadata size=${metadataVideoWidth}x$metadataVideoHeight rotation=$metadataVideoRotation scale=$videoContentScale zoom=$zoom")
+    }
+
+    private fun updateVideoScaleMetadataAndSendEvent(zoom: Float = this.zoom) {
+        val currentMediaItem = player.currentMediaItem ?: return
+        player.replaceMediaItem(
+            player.currentMediaItemIndex,
+            currentMediaItem.copy(videoZoom = zoom),
+        )
+        onEvent(VideoZoomEvent.ZoomChanged(currentMediaItem, zoom))
+    }
+}
+
+sealed interface VideoZoomEvent {
+    data class ContentScaleChanged(val contentScale: VideoContentScale) : VideoZoomEvent
+    data class ZoomChanged(val mediaItem: MediaItem, val zoom: Float) : VideoZoomEvent
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/VolumeAndBrightnessGestureState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/VolumeAndBrightnessGestureState.kt
new file mode 100644
index 000000000..9aa182110
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/VolumeAndBrightnessGestureState.kt
@@ -0,0 +1,132 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.pointer.PointerInputChange
+import androidx.compose.ui.unit.IntSize
+import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+@Composable
+fun rememberVolumeAndBrightnessGestureState(
+    volumeState: VolumeState,
+    brightnessState: BrightnessState,
+    isVolumeGestureEnabled: Boolean,
+    isBrightnessGestureEnabled: Boolean,
+    volumeGestureSensitivity: Float,
+    brightnessGestureSensitivity: Float,
+): VolumeAndBrightnessGestureState {
+    val coroutineScope = rememberCoroutineScope()
+    val volumeAndBrightnessGestureState = remember(volumeState, brightnessState) {
+        VolumeAndBrightnessGestureState(
+            volumeState = volumeState,
+            brightnessState = brightnessState,
+            isVolumeGestureEnabled = isVolumeGestureEnabled,
+            isBrightnessGestureEnabled = isBrightnessGestureEnabled,
+            volumeGestureSensitivity = volumeGestureSensitivity,
+            brightnessGestureSensitivity = brightnessGestureSensitivity,
+            coroutineScope = coroutineScope,
+        )
+    }
+    return volumeAndBrightnessGestureState
+}
+
+@Stable
+class VolumeAndBrightnessGestureState(
+    private val volumeState: VolumeState,
+    private val brightnessState: BrightnessState,
+    private val isVolumeGestureEnabled: Boolean = true,
+    private val isBrightnessGestureEnabled: Boolean = true,
+    private val volumeGestureSensitivity: Float,
+    private val brightnessGestureSensitivity: Float,
+    private val coroutineScope: CoroutineScope,
+) {
+    var activeGesture: VerticalGesture? by mutableStateOf(null)
+        private set
+
+    var volumeChangePercentage: Int by mutableIntStateOf(0)
+        private set
+
+    var brightnessChangePercentage: Int by mutableIntStateOf(0)
+        private set
+
+    private var startingY = 0f
+    private var startVolumePercentage = 0
+    private var startBrightnessPercentage = 0
+    private var job: Job? = null
+
+    fun onDragStart(offset: Offset, size: IntSize) {
+        val viewCenterX = size.width / 2
+        job?.cancel()
+        activeGesture = when {
+            offset.x < viewCenterX -> VerticalGesture.BRIGHTNESS.takeIf { isBrightnessGestureEnabled }
+            else -> VerticalGesture.VOLUME.takeIf { isVolumeGestureEnabled }
+        }
+        startingY = offset.y
+        startVolumePercentage = volumeState.volumePercentage
+        startBrightnessPercentage = brightnessState.brightnessPercentage
+    }
+
+    fun onDrag(change: PointerInputChange, dragAmount: Float) {
+        val activeGesture = activeGesture ?: return
+        if (change.isConsumed) return
+
+        when (activeGesture) {
+            VerticalGesture.VOLUME -> {
+                val maxVolumePercentage = volumeState.maxVolumePercentage
+                val volumeChange = (startingY - change.position.y) * (volumeGestureSensitivity / 10)
+                val newVolume = startVolumePercentage + volumeChange.toInt()
+                volumeChangePercentage = (newVolume - startVolumePercentage).coerceIn(
+                    minimumValue = 0 - startVolumePercentage,
+                    maximumValue = maxVolumePercentage - startVolumePercentage,
+                )
+                brightnessChangePercentage = 0
+                volumeState.updateVolumePercentage(newVolume)
+            }
+
+            VerticalGesture.BRIGHTNESS -> {
+                val brightnessChange = (startingY - change.position.y) * (brightnessGestureSensitivity / 10)
+                val newBrightness = startBrightnessPercentage + brightnessChange.toInt()
+                brightnessChangePercentage = (newBrightness - startBrightnessPercentage).coerceIn(
+                    minimumValue = 0 - startBrightnessPercentage,
+                    maximumValue = MAX_BRIGHTNESS_PERCENTAGE - startBrightnessPercentage,
+                )
+                volumeChangePercentage = 0
+                brightnessState.updateBrightnessPercentage(newBrightness)
+            }
+        }
+    }
+
+    fun onDragEnd() {
+        startingY = 0f
+        startVolumePercentage = 0
+        startBrightnessPercentage = 0
+
+        job?.cancel()
+        job = coroutineScope.launch {
+            delay(1.seconds)
+            activeGesture = null
+            volumeChangePercentage = 0
+            brightnessChangePercentage = 0
+        }
+    }
+
+    companion object {
+        private const val MAX_BRIGHTNESS_PERCENTAGE = 100
+    }
+}
+
+enum class VerticalGesture {
+    VOLUME,
+    BRIGHTNESS,
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/VolumeState.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/VolumeState.kt
new file mode 100644
index 000000000..89f97654f
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/state/VolumeState.kt
@@ -0,0 +1,225 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.state
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.media.AudioDeviceInfo
+import android.media.AudioManager
+import android.os.Build
+import androidx.annotation.OptIn
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.DisposableEffectResult
+import androidx.compose.runtime.DisposableEffectScope
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.core.content.ContextCompat.getSystemService
+import androidx.media3.common.Player
+import androidx.media3.common.listen
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.MediaController
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.getLoudnessGain
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.isLoudnessGainSupported
+import app.gyrolet.mpvrx.exoplayer.feature.player.service.setLoudnessGain
+
+@OptIn(UnstableApi::class)
+@Composable
+fun rememberVolumeState(
+    player: Player?,
+    shouldShowVolumePanelIfHeadsetIsOn: Boolean,
+    isVolumeBoostEnabled: Boolean,
+): VolumeState {
+    val context = LocalContext.current
+    val scope = rememberCoroutineScope()
+    val volumeState = remember(
+        player,
+        shouldShowVolumePanelIfHeadsetIsOn,
+        isVolumeBoostEnabled,
+    ) {
+        VolumeState(
+            player = player,
+            context = context,
+            shouldShowVolumePanelIfHeadsetIsOn = shouldShowVolumePanelIfHeadsetIsOn,
+            isVolumeBoostEnabled = isVolumeBoostEnabled,
+            scope = scope,
+        )
+    }
+    LaunchedEffect(player) { volumeState.initialize() }
+    DisposableEffect(context) { volumeState.handleLifecycle(this) }
+    return volumeState
+}
+
+@Stable
+class VolumeState(
+    private val player: Player?,
+    private val context: Context,
+    private val shouldShowVolumePanelIfHeadsetIsOn: Boolean,
+    private val isVolumeBoostEnabled: Boolean,
+    private val scope: CoroutineScope,
+) {
+    private val audioManager = getSystemService(context, AudioManager::class.java)!!
+
+    private val systemMaxVolume: Int = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC)
+
+    private var isLoudnessGainSupported: Boolean by mutableStateOf(false)
+
+    val maxVolume: Int
+        get() = if (isLoudnessGainSupported) systemMaxVolume * 2 else systemMaxVolume
+
+    val maxVolumePercentage: Int
+        get() = if (isLoudnessGainSupported) MAX_VOLUME_PERCENTAGE_BOOST else MAX_VOLUME_PERCENTAGE_NORMAL
+
+    var currentVolume: Int by mutableIntStateOf(audioManager.currentStreamVolume)
+        private set
+
+    var volumePercentage: Int by mutableIntStateOf(calculateVolumePercentage())
+        private set
+
+    fun updateVolumePercentage(percentage: Int) {
+        val maxPercentage = if (isVolumeBoostEnabled) {
+            MAX_VOLUME_PERCENTAGE_BOOST
+        } else {
+            maxVolumePercentage
+        }
+        val clampedPercentage = percentage.coerceIn(0, maxPercentage)
+        val targetVolume = (clampedPercentage * systemMaxVolume) / MAX_VOLUME_PERCENTAGE_NORMAL
+        Logger.debug(TAG, "Restore player volume: percentage=$clampedPercentage, targetVolume=$targetVolume")
+
+        setVolume(targetVolume)
+    }
+
+    fun increaseVolume(shouldShowVolumePanel: Boolean = false) {
+        setVolume(currentVolume + 1, shouldShowVolumePanel)
+    }
+
+    fun decreaseVolume(shouldShowVolumePanel: Boolean = false) {
+        setVolume(currentVolume - 1, shouldShowVolumePanel)
+    }
+
+    fun handleLifecycle(disposableEffectScope: DisposableEffectScope): DisposableEffectResult = with(disposableEffectScope) {
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                if (intent.action == VOLUME_CHANGED_ACTION) {
+                    val systemVolume = audioManager.currentStreamVolume
+                    if (currentVolume > systemMaxVolume && systemVolume == systemMaxVolume) return
+                    currentVolume = systemVolume
+                    volumePercentage = calculateVolumePercentage()
+                    if (isVolumeBoostEnabled) {
+                        applyVolumeBoost(0)
+                    }
+                }
+            }
+        }
+
+        context.registerReceiver(receiver, IntentFilter(VOLUME_CHANGED_ACTION))
+
+        onDispose {
+            context.unregisterReceiver(receiver)
+        }
+    }
+
+    suspend fun initialize() {
+        val player = player as? MediaController ?: return
+        isLoudnessGainSupported = isVolumeBoostEnabled && player.isLoudnessGainSupported()
+        val loudnessGain = player.getLoudnessGain()
+        val systemVolume = audioManager.currentStreamVolume
+
+        if (loudnessGain > 0 && isLoudnessGainSupported) {
+            if (systemVolume < systemMaxVolume) {
+                currentVolume = systemVolume
+                volumePercentage = calculateVolumePercentage()
+                player.setLoudnessGain(0)
+            } else {
+                val boostVolume = (loudnessGain * systemMaxVolume) / MAX_BOOST_GAIN_MB
+                currentVolume = systemMaxVolume + boostVolume
+                volumePercentage = calculateVolumePercentage()
+            }
+        }
+
+        player.listen { events ->
+            if (events.contains(Player.EVENT_AUDIO_SESSION_ID)) {
+                scope.launch {
+                    isLoudnessGainSupported = isVolumeBoostEnabled && player.isLoudnessGainSupported()
+                }
+            }
+        }
+    }
+
+    private fun setVolume(volume: Int, shouldShowVolumePanel: Boolean = false) {
+        val clampedVolume = volume.coerceIn(0, maximumAllowedVolume)
+        currentVolume = clampedVolume
+        volumePercentage = calculateVolumePercentage()
+
+        Logger.debug(TAG, "Set player volume: current=$clampedVolume, percentage=$volumePercentage, boostEnabled=$isVolumeBoostEnabled")
+
+        if (!isVolumeBoostEnabled) {
+            setSystemVolume(clampedVolume, shouldShowVolumePanel)
+            applyVolumeBoost(0)
+            return
+        }
+
+        if (clampedVolume <= systemMaxVolume) {
+            setSystemVolume(clampedVolume, shouldShowVolumePanel)
+            applyVolumeBoost(0)
+        } else {
+            setSystemVolume(systemMaxVolume, shouldShowVolumePanel)
+            applyVolumeBoost(clampedVolume - systemMaxVolume)
+        }
+    }
+
+    private val maximumAllowedVolume: Int
+        get() = if (isVolumeBoostEnabled) systemMaxVolume * 2 else maxVolume
+
+    private fun setSystemVolume(volume: Int, shouldShowVolumePanel: Boolean) {
+        val shouldShowUi = shouldShowVolumePanel || (shouldShowVolumePanelIfHeadsetIsOn && audioManager.isHeadsetOn)
+        audioManager.setStreamVolume(
+            AudioManager.STREAM_MUSIC,
+            volume.coerceIn(0, systemMaxVolume),
+            if (shouldShowUi) AudioManager.FLAG_SHOW_UI else 0,
+        )
+    }
+
+    private fun applyVolumeBoost(volume: Int) {
+        val player = player as? MediaController ?: return
+        val gainMillibels = (volume.toFloat() / systemMaxVolume * MAX_BOOST_GAIN_MB).toInt()
+
+        try {
+            player.setLoudnessGain(gainMillibels)
+        } catch (e: Exception) {
+            Logger.error(TAG, "Failed to apply volume boost", e)
+        }
+    }
+
+    private fun calculateVolumePercentage(): Int = (currentVolume.toFloat() / systemMaxVolume * MAX_VOLUME_PERCENTAGE_NORMAL).toInt()
+
+    private val AudioManager.currentStreamVolume: Int
+        get() = getStreamVolume(AudioManager.STREAM_MUSIC)
+
+    private val AudioManager.isHeadsetOn: Boolean
+        get() = getDevices(AudioManager.GET_DEVICES_OUTPUTS).any { device ->
+            device.type == AudioDeviceInfo.TYPE_WIRED_HEADSET ||
+                device.type == AudioDeviceInfo.TYPE_WIRED_HEADPHONES ||
+                device.type == AudioDeviceInfo.TYPE_BLUETOOTH_A2DP ||
+                device.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO ||
+                (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && device.type == AudioDeviceInfo.TYPE_USB_HEADSET)
+        }
+
+    companion object {
+        private const val TAG = "VolumeState"
+        private const val VOLUME_CHANGED_ACTION = "android.media.VOLUME_CHANGED_ACTION"
+        private const val MAX_VOLUME_PERCENTAGE_NORMAL = 100
+        private const val MAX_VOLUME_PERCENTAGE_BOOST = 200
+        private const val MAX_BOOST_GAIN_MB = 2000
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/subtitle/AssHandlerRegistry.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/subtitle/AssHandlerRegistry.kt
new file mode 100644
index 000000000..02f31337a
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/subtitle/AssHandlerRegistry.kt
@@ -0,0 +1,23 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.subtitle
+
+import io.github.peerless2012.ass.media.AssHandler
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+object AssHandlerRegistry {
+
+    private val currentHandler = MutableStateFlow<AssHandler?>(null)
+
+    val handler: StateFlow<AssHandler?> = currentHandler.asStateFlow()
+
+    fun register(handler: AssHandler) {
+        currentHandler.value = handler
+    }
+
+    fun unregister(handler: AssHandler) {
+        if (currentHandler.value === handler) {
+            currentHandler.value = null
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/subtitle/NormalizingAssMatroskaExtractor.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/subtitle/NormalizingAssMatroskaExtractor.kt
new file mode 100644
index 000000000..f67a72abc
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/subtitle/NormalizingAssMatroskaExtractor.kt
@@ -0,0 +1,322 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.subtitle
+
+import androidx.media3.common.C
+import androidx.media3.common.Format
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.ParserException
+import androidx.media3.common.util.ParsableByteArray
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.extractor.ExtractorInput
+import androidx.media3.extractor.ExtractorOutput
+import androidx.media3.extractor.TrackOutput
+import androidx.media3.extractor.mkv.MatroskaExtractor
+import androidx.media3.extractor.text.SubtitleParser
+import io.github.peerless2012.ass.media.AssHandler
+import io.github.peerless2012.ass.media.type.AssRenderType
+import java.lang.reflect.Field
+import java.util.regex.Pattern
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.normalizeAssDialogueFields
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.normalizeAssSubtitleText
+
+@UnstableApi
+internal class NormalizingAssMatroskaExtractor(
+    subtitleParserFactory: SubtitleParser.Factory,
+    private val assHandler: AssHandler,
+) : MatroskaExtractor(subtitleParserFactory) {
+
+    private var currentAttachmentName: String? = null
+    private var currentAttachmentMime: String? = null
+    private val subtitleSample = subtitleSampleField?.get(this) as? ParsableByteArray
+
+    override fun getElementType(id: Int): Int = when (id) {
+        ID_ATTACHMENTS,
+        ID_ATTACHED_FILE,
+        -> ELEMENT_TYPE_MASTER
+        ID_FILE_NAME,
+        ID_FILE_MIME_TYPE,
+        -> ELEMENT_TYPE_STRING
+        ID_FILE_DATA -> ELEMENT_TYPE_BINARY
+        else -> super.getElementType(id)
+    }
+
+    override fun isLevel1Element(id: Int): Boolean = super.isLevel1Element(id) || id == ID_ATTACHMENTS
+
+    @Throws(ParserException::class)
+    override fun startMasterElement(
+        id: Int,
+        contentPosition: Long,
+        contentSize: Long,
+    ) {
+        when (id) {
+            ID_EBML -> {
+                wrapExtractorOutput()
+                super.startMasterElement(id, contentPosition, contentSize)
+            }
+            ID_ATTACHED_FILE -> clearAttachment()
+            else -> super.startMasterElement(id, contentPosition, contentSize)
+        }
+    }
+
+    @Throws(ParserException::class)
+    override fun endMasterElement(id: Int) {
+        when (id) {
+            ID_VIDEO -> {
+                val track = getCurrentTrack(id)
+                assHandler.setVideoSize(track.width, track.height)
+                super.endMasterElement(id)
+            }
+            ID_ATTACHED_FILE -> clearAttachment()
+            else -> super.endMasterElement(id)
+        }
+    }
+
+    @Throws(ParserException::class)
+    override fun stringElement(id: Int, value: String) {
+        when (id) {
+            ID_FILE_NAME -> currentAttachmentName = value
+            ID_FILE_MIME_TYPE -> currentAttachmentMime = value
+            else -> super.stringElement(id, value)
+        }
+    }
+
+    override fun binaryElement(
+        id: Int,
+        contentSize: Int,
+        input: ExtractorInput,
+    ) {
+        if (id != ID_FILE_DATA) {
+            super.binaryElement(id, contentSize, input)
+            return
+        }
+
+        val name = requireNotNull(currentAttachmentName)
+        val mime = requireNotNull(currentAttachmentMime)
+        if (mime in FONT_MIME_TYPES) {
+            val data = ByteArray(contentSize)
+            input.readFully(data, 0, contentSize)
+            assHandler.addFont(name, data)
+        } else {
+            input.skipFully(contentSize)
+        }
+    }
+
+    private fun wrapExtractorOutput() {
+        if (assHandler.renderType == AssRenderType.CUES) return
+
+        val output = extractorOutputField?.get(this) as? ExtractorOutput ?: return
+        if (output is NormalizingAssSubtitleExtractorOutput) return
+
+        extractorOutputField?.set(
+            this,
+            NormalizingAssSubtitleExtractorOutput(
+                delegate = output,
+                assHandler = assHandler,
+                extractor = this,
+            ),
+        )
+    }
+
+    private fun clearAttachment() {
+        currentAttachmentName = null
+        currentAttachmentMime = null
+    }
+
+    internal fun getSubtitleSample(): ParsableByteArray? = subtitleSample
+
+    companion object {
+        private const val ID_EBML = 0x1A45DFA3
+        private const val ID_VIDEO = 0xE0
+        private const val ID_ATTACHMENTS = 0x1941A469
+        private const val ID_ATTACHED_FILE = 0x61A7
+        private const val ID_FILE_NAME = 0x466E
+        private const val ID_FILE_MIME_TYPE = 0x4660
+        private const val ID_FILE_DATA = 0x465C
+
+        private const val ELEMENT_TYPE_MASTER = 1
+        private const val ELEMENT_TYPE_STRING = 3
+        private const val ELEMENT_TYPE_BINARY = 4
+
+        private val FONT_MIME_TYPES = setOf(
+            "font/ttf",
+            "font/otf",
+            "font/sfnt",
+            "font/woff",
+            "font/woff2",
+            "application/font-sfnt",
+            "application/font-woff",
+            "application/x-truetype-font",
+            "application/vnd.ms-opentype",
+            "application/x-font-ttf",
+        )
+
+        private val extractorOutputField: Field? = runCatching {
+            MatroskaExtractor::class.java.getDeclaredField("extractorOutput").apply {
+                isAccessible = true
+            }
+        }.getOrNull()
+
+        private val subtitleSampleField: Field? = runCatching {
+            MatroskaExtractor::class.java.getDeclaredField("subtitleSample").apply {
+                isAccessible = true
+            }
+        }.getOrNull()
+    }
+}
+
+@UnstableApi
+private class NormalizingAssSubtitleExtractorOutput(
+    private val delegate: ExtractorOutput,
+    private val assHandler: AssHandler,
+    private val extractor: NormalizingAssMatroskaExtractor,
+) : ExtractorOutput {
+
+    override fun track(id: Int, type: Int): TrackOutput {
+        val output = delegate.track(id, type)
+        return if (type == C.TRACK_TYPE_TEXT) {
+            NormalizingAssTrackOutput(
+                delegate = output,
+                assHandler = assHandler,
+                extractor = extractor,
+            )
+        } else {
+            output
+        }
+    }
+
+    override fun endTracks() = delegate.endTracks()
+
+    override fun seekMap(seekMap: androidx.media3.extractor.SeekMap) = delegate.seekMap(seekMap)
+}
+
+@UnstableApi
+private class NormalizingAssTrackOutput(
+    private val delegate: TrackOutput,
+    private val assHandler: AssHandler,
+    private val extractor: NormalizingAssMatroskaExtractor,
+) : TrackOutput {
+
+    private var isAss = false
+    private var trackId: String? = null
+
+    override fun format(format: Format) {
+        isAss = format.sampleMimeType == MimeTypes.TEXT_SSA || format.codecs == MimeTypes.TEXT_SSA
+        trackId = format.id
+        val normalizedFormat = if (isAss) format.normalizeAssHeader() else format
+        delegate.format(normalizedFormat)
+    }
+
+    override fun sampleData(
+        input: androidx.media3.common.DataReader,
+        length: Int,
+        allowEndOfInput: Boolean,
+        sampleDataPart: Int,
+    ): Int = delegate.sampleData(input, length, allowEndOfInput, sampleDataPart)
+
+    override fun sampleData(
+        data: ParsableByteArray,
+        length: Int,
+        sampleDataPart: Int,
+    ) = delegate.sampleData(data, length, sampleDataPart)
+
+    override fun sampleMetadata(
+        timeUs: Long,
+        flags: Int,
+        size: Int,
+        offset: Int,
+        cryptoData: TrackOutput.CryptoData?,
+    ) {
+        if (isAss && timeUs != C.TIME_UNSET) {
+            readAssDialogue(timeUs)
+        }
+        delegate.sampleMetadata(timeUs, flags, size, offset, cryptoData)
+    }
+
+    private fun readAssDialogue(timeUs: Long) {
+        val trackId = trackId ?: return
+        val sample = extractor.getSubtitleSample() ?: return
+        val data = sample.data
+        val firstComma = findTokenIndex(data, 1)
+        val secondComma = findTokenIndex(data, 2)
+        if (firstComma <= 0 || secondComma <= firstComma) return
+
+        val endTimeUs = parseTimecodeUs(data.decodeToString(firstComma, secondComma - 1))
+        if (endTimeUs == C.TIME_UNSET) return
+
+        val normalizedData = normalizeSampleData(data, secondComma, sample.limit())
+        assHandler.readTrackDialogue(
+            trackId,
+            timeUs / 1000,
+            endTimeUs / 1000,
+            normalizedData,
+            secondComma,
+            normalizedData.size - secondComma,
+        )
+    }
+
+    private fun normalizeSampleData(
+        data: ByteArray,
+        textOffset: Int,
+        limit: Int,
+    ): ByteArray {
+        val fields = data.decodeToString(textOffset, limit)
+        val normalizedFields = fields.normalizeAssDialogueFields(ASS_MATROSKA_TEXT_INDEX)
+        if (normalizedFields == fields) return data.copyOf(limit)
+
+        val normalizedFieldBytes = normalizedFields.encodeToByteArray()
+        return ByteArray(textOffset + normalizedFieldBytes.size).also { normalizedData ->
+            data.copyInto(normalizedData, endIndex = textOffset)
+            normalizedFieldBytes.copyInto(normalizedData, destinationOffset = textOffset)
+        }
+    }
+
+    private fun Format.normalizeAssHeader(): Format {
+        if (initializationData.isEmpty()) return this
+
+        var hasChanges = false
+        val normalizedInitializationData = initializationData.map { data ->
+            val sourceText = data.decodeToString()
+            val normalizedText = sourceText.normalizeAssSubtitleText()
+            if (normalizedText != sourceText) {
+                hasChanges = true
+                normalizedText.encodeToByteArray()
+            } else {
+                data
+            }
+        }
+        if (!hasChanges) return this
+
+        return buildUpon()
+            .setInitializationData(normalizedInitializationData)
+            .build()
+    }
+
+    private fun findTokenIndex(data: ByteArray, token: Int): Int {
+        if (token == 0) return 0
+
+        var count = 0
+        for (index in data.indices) {
+            if (data[index] == COMMA) {
+                count++
+                if (count == token) return index + 1
+            }
+        }
+        return 0
+    }
+
+    private fun parseTimecodeUs(timecode: String): Long {
+        val matcher = SSA_TIMECODE_PATTERN.matcher(timecode.trim())
+        if (!matcher.matches()) return C.TIME_UNSET
+
+        val hours = matcher.group(1)?.toLongOrNull() ?: 0L
+        val minutes = matcher.group(2)?.toLongOrNull() ?: return C.TIME_UNSET
+        val seconds = matcher.group(3)?.toLongOrNull() ?: return C.TIME_UNSET
+        val hundredths = matcher.group(4)?.toLongOrNull() ?: return C.TIME_UNSET
+        return ((hours * 60 + minutes) * 60 + seconds) * 1_000_000 + hundredths * 10_000
+    }
+
+    companion object {
+        private const val COMMA = ','.code.toByte()
+        private const val ASS_MATROSKA_TEXT_INDEX = 8
+        private val SSA_TIMECODE_PATTERN: Pattern = Pattern.compile("(?:(\\d+):)?(\\d+):(\\d+)[:.](\\d+)")
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/subtitle/SubtitleFontPolicy.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/subtitle/SubtitleFontPolicy.kt
new file mode 100644
index 000000000..aa0af491f
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/subtitle/SubtitleFontPolicy.kt
@@ -0,0 +1,17 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.subtitle
+
+enum class SubtitleFontPolicy {
+    Ass,
+    SystemCaptionStyle,
+    ExternalOrFallback,
+}
+
+fun decideSubtitleFontPolicy(
+    isAssSubtitleSelected: Boolean,
+    shouldUseSystemCaptionStyle: Boolean,
+    hasExternalFont: Boolean,
+): SubtitleFontPolicy {
+    if (isAssSubtitleSelected) return SubtitleFontPolicy.Ass
+    if (shouldUseSystemCaptionStyle) return SubtitleFontPolicy.SystemCaptionStyle
+    return SubtitleFontPolicy.ExternalOrFallback
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/AudioTrackSelectorView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/AudioTrackSelectorView.kt
new file mode 100644
index 000000000..553e72a8c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/AudioTrackSelectorView.kt
@@ -0,0 +1,129 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.annotation.OptIn
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectableGroup
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.media3.common.C
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.getName
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberTracksState
+
+@OptIn(UnstableApi::class)
+@Composable
+fun BoxScope.AudioTrackSelectorView(
+    modifier: Modifier = Modifier,
+    shouldShow: Boolean,
+    player: Player,
+    onDismiss: () -> Unit,
+) {
+    OverlayView(
+        modifier = modifier,
+        shouldShow = shouldShow,
+        title = stringResource(R.string.select_audio_track),
+    ) {
+        AudioTrackSelectorContent(
+            player = player,
+            onDismiss = onDismiss,
+        )
+    }
+}
+
+@OptIn(UnstableApi::class)
+@Composable
+fun AudioTrackSelectorContent(
+    player: Player,
+    onDismiss: () -> Unit,
+) {
+    val audioTracksState = rememberTracksState(player, C.TRACK_TYPE_AUDIO)
+    Column(
+        modifier = Modifier
+            .verticalScroll(rememberScrollState())
+            .padding(bottom = 24.dp)
+            .padding(horizontal = 24.dp)
+            .selectableGroup(),
+    ) {
+        audioTracksState.tracks.forEachIndexed { index, track ->
+            RadioButtonRow(
+                isSelected = track.isSelected,
+                text = track.mediaTrackGroup.getName(C.TRACK_TYPE_AUDIO, index),
+                onClick = {
+                    audioTracksState.switchTrack(index)
+                    onDismiss()
+                },
+            )
+        }
+        RadioButtonRow(
+            isSelected = audioTracksState.tracks.none { it.isSelected },
+            text = stringResource(R.string.disable),
+            onClick = {
+                audioTracksState.switchTrack(-1)
+                onDismiss()
+            },
+        )
+    }
+}
+
+@OptIn(UnstableApi::class)
+@Composable
+fun BoxScope.SubtitleTrackSelectorView(
+    modifier: Modifier = Modifier,
+    shouldShow: Boolean,
+    player: Player,
+    onDismiss: () -> Unit,
+) {
+    OverlayView(
+        modifier = modifier,
+        shouldShow = shouldShow,
+        title = stringResource(R.string.select_subtitle_track),
+    ) {
+        SubtitleTrackSelectorContent(
+            player = player,
+            onDismiss = onDismiss,
+        )
+    }
+}
+
+@OptIn(UnstableApi::class)
+@Composable
+fun SubtitleTrackSelectorContent(
+    player: Player,
+    onDismiss: () -> Unit,
+) {
+    val subtitleTracksState = rememberTracksState(player, C.TRACK_TYPE_TEXT)
+    Column(
+        modifier = Modifier
+            .verticalScroll(rememberScrollState())
+            .padding(bottom = 24.dp)
+            .padding(horizontal = 24.dp)
+            .selectableGroup(),
+    ) {
+        subtitleTracksState.tracks.forEachIndexed { index, track ->
+            RadioButtonRow(
+                isSelected = track.isSelected,
+                text = track.mediaTrackGroup.getName(C.TRACK_TYPE_TEXT, index),
+                onClick = {
+                    subtitleTracksState.switchTrack(index)
+                    onDismiss()
+                },
+            )
+        }
+        RadioButtonRow(
+            isSelected = subtitleTracksState.tracks.none { it.isSelected },
+            text = stringResource(R.string.disable),
+            onClick = {
+                subtitleTracksState.switchTrack(-1)
+                onDismiss()
+            },
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/DecoderPrioritySelectorView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/DecoderPrioritySelectorView.kt
new file mode 100644
index 000000000..47068e5da
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/DecoderPrioritySelectorView.kt
@@ -0,0 +1,80 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectableGroup
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+import app.gyrolet.mpvrx.R
+
+@Composable
+fun BoxScope.DecoderPrioritySelectorView(
+    modifier: Modifier = Modifier,
+    shouldShow: Boolean,
+    currentDecoderPriority: DecoderPriority,
+    onDecoderPriorityClick: (DecoderPriority) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    OverlayView(
+        modifier = modifier,
+        shouldShow = shouldShow,
+        title = stringResource(R.string.decoder_priority),
+        testTag = "panel_decoder_priority",
+    ) {
+        DecoderPrioritySelectorContent(
+            currentDecoderPriority = currentDecoderPriority,
+            onDecoderPriorityClick = onDecoderPriorityClick,
+            onDismiss = onDismiss,
+        )
+    }
+}
+
+@Composable
+fun DecoderPrioritySelectorContent(
+    currentDecoderPriority: DecoderPriority,
+    onDecoderPriorityClick: (DecoderPriority) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    Column(
+        modifier = Modifier
+            .verticalScroll(rememberScrollState())
+            .padding(bottom = 24.dp)
+            .padding(horizontal = 24.dp)
+            .selectableGroup(),
+    ) {
+        DecoderPriority.entries.forEach { decoderPriority ->
+            RadioButtonRow(
+                isSelected = decoderPriority == currentDecoderPriority,
+                text = decoderPriority.shortName(),
+                testTag = "btn_decoder_${decoderPriority.logSuffix()}",
+                onClick = {
+                    onDecoderPriorityClick(decoderPriority)
+                    onDismiss()
+                },
+            )
+        }
+    }
+}
+
+@Composable
+private fun DecoderPriority.shortName(): String = when (this) {
+    DecoderPriority.AUTOMATIC -> stringResource(R.string.auto_hw_decoder)
+    DecoderPriority.AUTOMATIC_PREFER_DEVICE -> stringResource(R.string.auto_hw_plus_decoder)
+    DecoderPriority.DEVICE_ONLY -> stringResource(R.string.hw_decoder)
+    DecoderPriority.PREFER_DEVICE -> stringResource(R.string.hw_plus_decoder)
+    DecoderPriority.PREFER_APP -> stringResource(R.string.sw_decoder)
+}
+
+private fun DecoderPriority.logSuffix(): String = when (this) {
+    DecoderPriority.AUTOMATIC -> "auto_hw"
+    DecoderPriority.AUTOMATIC_PREFER_DEVICE -> "auto_hw_plus"
+    DecoderPriority.DEVICE_ONLY -> "hw"
+    DecoderPriority.PREFER_DEVICE -> "hw_plus"
+    DecoderPriority.PREFER_APP -> "sw"
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/DeviceStatsOverlay.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/DeviceStatsOverlay.kt
new file mode 100644
index 000000000..0620d6102
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/DeviceStatsOverlay.kt
@@ -0,0 +1,403 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import android.app.ActivityManager
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.BatteryManager
+import android.os.Build
+import android.view.WindowManager
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.HorizontalDivider
+import app.gyrolet.mpvrx.ui.icons.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.annotation.OptIn
+import androidx.media3.common.C
+import androidx.media3.common.Format
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import kotlinx.coroutines.delay
+import java.io.BufferedReader
+import java.io.FileReader
+
+data class DeviceStats(
+    val cpuPercent: Int = 0,
+    val tempCelsius: Float = 0f,
+    val usedMemMb: Long = 0,
+    val totalMemMb: Long = 0,
+    val batteryPercent: Int = 0,
+    val batteryCharging: Boolean = false,
+    val videoFps: Float = 0f
+)
+
+data class PlaybackStats(
+    val videoResolution: String = "N/A",
+    val videoCodec: String = "N/A",
+    val videoBitrate: String = "N/A",
+    val audioCodec: String = "N/A",
+    val audioSampleRate: String = "N/A",
+    val audioChannels: String = "N/A",
+    val bufferHealth: String = "0 / 0 ms",
+    val playbackSpeed: String = "1.0x",
+    val displayRefreshRate: String = "N/A",
+    val screenResolution: String = "N/A",
+    val reportedFps: Float = 0f,
+    val formatFps: Float = 0f
+)
+
+@Composable
+fun DeviceStatsOverlay(
+    visible: Boolean,
+    player: Player?,
+    modifier: Modifier = Modifier,
+    videoFps: Float = 0f,
+    videoDecoderName: String? = null,
+    onDismiss: () -> Unit = {}
+) {
+    val context = LocalContext.current
+    var deviceStats by remember { mutableStateOf(DeviceStats()) }
+    var playbackStats by remember { mutableStateOf(PlaybackStats()) }
+
+    LaunchedEffect(visible) {
+        if (visible) {
+            while (true) {
+                deviceStats = collectStats(context, videoFps)
+                playbackStats = collectPlaybackStats(player, context, videoFps)
+                delay(1000)
+            }
+        }
+    }
+
+    AnimatedVisibility(
+        visible = visible,
+        enter = fadeIn(),
+        exit = fadeOut(),
+        modifier = modifier
+    ) {
+        Card(
+            modifier = Modifier
+                .widthIn(min = 280.dp, max = 340.dp)
+                .padding(16.dp),
+            shape = RoundedCornerShape(16.dp),
+            colors = CardDefaults.cardColors(
+                containerColor = MaterialTheme.colorScheme.surface.copy(alpha = 0.85f)
+            )
+        ) {
+            Column(
+                modifier = Modifier
+                    .padding(16.dp)
+                    .verticalScroll(rememberScrollState()),
+                verticalArrangement = Arrangement.spacedBy(10.dp)
+            ) {
+                // Header with Close
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    Text(
+                        text = "STATS FOR NERDS",
+                        color = MaterialTheme.colorScheme.onSurface,
+                        style = MaterialTheme.typography.labelMedium,
+                        fontWeight = FontWeight.Bold
+                    )
+                    IconButton(onClick = onDismiss, modifier = Modifier.padding(0.dp)) {
+                        Icon(
+                            imageVector = NextIcons.Close,
+                            contentDescription = "Close Stats",
+                            tint = MaterialTheme.colorScheme.onSurface
+                        )
+                    }
+                }
+
+                HorizontalDivider(color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.2f))
+
+                // Video Details
+                StatsSectionHeader("VIDEO")
+                StatItem("Resolution", playbackStats.videoResolution)
+                StatItem("Codec", playbackStats.videoCodec)
+                
+                val decoderLabel = when {
+                    videoDecoderName == null -> "-"
+                    videoDecoderName.contains("c2.android", ignoreCase = true) -> "[SW] $videoDecoderName"
+                    videoDecoderName.contains("omx.google", ignoreCase = true) -> "[SW] $videoDecoderName"
+                    videoDecoderName.contains("ffmpeg", ignoreCase = true) -> "[SW] $videoDecoderName"
+                    else -> "[HW] $videoDecoderName"
+                }
+                StatItem("Decoder", decoderLabel, if (decoderLabel.contains("[SW]")) Color(0xFFFF9800) else Color(0xFF4CAF50))
+                
+                val fpsToDisplay = if (playbackStats.reportedFps > 0f) {
+                    "%.2f fps".format(playbackStats.reportedFps)
+                } else if (playbackStats.formatFps > 0f) {
+                    "%.2f fps".format(playbackStats.formatFps)
+                } else {
+                    "N/A"
+                }
+                StatItem("Framerate", fpsToDisplay)
+                StatItem("Bitrate", playbackStats.videoBitrate)
+
+                // Audio Details
+                HorizontalDivider(color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.2f))
+                StatsSectionHeader("AUDIO")
+                StatItem("Codec", playbackStats.audioCodec)
+                StatItem("Sample Rate", playbackStats.audioSampleRate)
+                StatItem("Channels", playbackStats.audioChannels)
+
+                // Playback Health
+                HorizontalDivider(color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.2f))
+                StatsSectionHeader("PLAYBACK")
+                StatItem("Buffer (Buf/Cur)", playbackStats.bufferHealth)
+                StatItem("Speed", playbackStats.playbackSpeed)
+
+                // Device Display
+                HorizontalDivider(color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.2f))
+                StatsSectionHeader("DISPLAY")
+                StatItem("Refresh Rate", playbackStats.displayRefreshRate)
+                StatItem("Resolution", playbackStats.screenResolution)
+
+                // System Specs
+                HorizontalDivider(color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.2f))
+                StatsSectionHeader("SYSTEM")
+                StatItem("CPU", "${deviceStats.cpuPercent}%", levelColor(deviceStats.cpuPercent.toFloat() / 100f))
+                StatItem("Memory", "${deviceStats.usedMemMb} / ${deviceStats.totalMemMb} MB", Color.Cyan.copy(alpha = 0.85f))
+                StatItem(
+                    "Battery",
+                    "${deviceStats.batteryPercent}% ${if (deviceStats.batteryCharging) "⚡" else ""}",
+                    batteryColor(deviceStats.batteryPercent)
+                )
+                StatItem(
+                    "Temp",
+                    if (deviceStats.tempCelsius > 0f) "%.1f°C".format(deviceStats.tempCelsius) else "N/A",
+                    tempColor(deviceStats.tempCelsius)
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun StatsSectionHeader(title: String) {
+    Text(
+        text = title,
+        color = MaterialTheme.colorScheme.primary,
+        style = MaterialTheme.typography.labelMedium,
+        fontWeight = FontWeight.Bold,
+        letterSpacing = 1.0.sp
+    )
+}
+
+@Composable
+private fun StatItem(label: String, value: String, valueColor: Color = MaterialTheme.colorScheme.onSurface) {
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp),
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Text(
+            text = label,
+            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f),
+            style = MaterialTheme.typography.bodySmall,
+            modifier = Modifier.weight(1f)
+        )
+        Text(
+            text = value,
+            color = valueColor,
+            style = MaterialTheme.typography.bodySmall,
+            fontWeight = FontWeight.SemiBold,
+            fontFamily = FontFamily.Monospace,
+            textAlign = androidx.compose.ui.text.style.TextAlign.End,
+            modifier = Modifier.padding(start = 8.dp)
+        )
+    }
+}
+
+@OptIn(UnstableApi::class)
+private fun collectPlaybackStats(player: Player?, context: Context, reportedFps: Float): PlaybackStats {
+    var vRes = "N/A"
+    var vCodec = "N/A"
+    var vBitrate = "N/A"
+    var aCodec = "N/A"
+    var aSampleRate = "N/A"
+    var aChannels = "N/A"
+    var formatFps = 0f
+
+    val groups = player?.currentTracks?.groups ?: emptyList()
+    for (group in groups) {
+        if (group.isSelected) {
+            if (group.type == C.TRACK_TYPE_VIDEO) {
+                // Get the first selected track format
+                for (i in 0 until group.length) {
+                    if (group.isTrackSelected(i)) {
+                        val format = group.getTrackFormat(i)
+                        vRes = if (format.width != Format.NO_VALUE && format.height != Format.NO_VALUE) {
+                            "${format.width}x${format.height}"
+                        } else "N/A"
+                        vCodec = format.sampleMimeType ?: "N/A"
+                        vBitrate = if (format.bitrate != Format.NO_VALUE) "${format.bitrate / 1000} kbps" else "N/A"
+                        formatFps = if (format.frameRate != Format.NO_VALUE.toFloat() && format.frameRate > 0f) format.frameRate else 0f
+                        break
+                    }
+                }
+            } else if (group.type == C.TRACK_TYPE_AUDIO) {
+                for (i in 0 until group.length) {
+                    if (group.isTrackSelected(i)) {
+                        val format = group.getTrackFormat(i)
+                        aCodec = format.sampleMimeType ?: "N/A"
+                        aSampleRate = if (format.sampleRate != Format.NO_VALUE) "${format.sampleRate} Hz" else "N/A"
+                        aChannels = when (format.channelCount) {
+                            1 -> "Mono (1)"
+                            2 -> "Stereo (2)"
+                            6 -> "5.1 (6)"
+                            8 -> "7.1 (8)"
+                            Format.NO_VALUE -> "N/A"
+                            else -> "${format.channelCount} ch"
+                        }
+                        break
+                    }
+                }
+            }
+        }
+    }
+
+    val bufferPos = player?.bufferedPosition ?: 0L
+    val currentPos = player?.currentPosition ?: 0L
+    val bufferHealth = "%.1f / %.1f s".format(bufferPos / 1000f, currentPos / 1000f)
+    val speed = player?.playbackParameters?.speed ?: 1f
+    
+    val display = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        context.display
+    } else {
+        @Suppress("DEPRECATION")
+        (context.getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay
+    }
+    val refreshRate = display?.refreshRate ?: 0f
+
+    val screenRes = context.resources.displayMetrics.run { "${widthPixels}x${heightPixels}" }
+
+    return PlaybackStats(
+        videoResolution = vRes,
+        videoCodec = vCodec,
+        videoBitrate = vBitrate,
+        audioCodec = aCodec,
+        audioSampleRate = aSampleRate,
+        audioChannels = aChannels,
+        bufferHealth = bufferHealth,
+        playbackSpeed = "%.2fx".format(speed),
+        displayRefreshRate = if (refreshRate > 0f) "%.1f Hz".format(refreshRate) else "N/A",
+        screenResolution = screenRes,
+        reportedFps = reportedFps,
+        formatFps = formatFps
+    )
+}
+
+private fun levelColor(level: Float): Color = when {
+    level < 0.5f -> Color(0xFF4CAF50)   // green
+    level < 0.75f -> Color(0xFFFF9800)  // orange
+    else -> Color(0xFFF44336)           // red
+}
+
+private fun tempColor(temp: Float): Color = when {
+    temp <= 0f -> Color.White
+    temp < 40f -> Color(0xFF4CAF50)
+    temp < 50f -> Color(0xFFFF9800)
+    else -> Color(0xFFF44336)
+}
+
+private fun batteryColor(percent: Int): Color = when {
+    percent > 50 -> Color(0xFF4CAF50)
+    percent > 20 -> Color(0xFFFF9800)
+    else -> Color(0xFFF44336)
+}
+
+private fun collectStats(context: Context, videoFps: Float): DeviceStats {
+    // CPU
+    val cpu = readCpuUsage()
+
+    // Memory
+    val am = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+    val memInfo = ActivityManager.MemoryInfo()
+    am.getMemoryInfo(memInfo)
+    val totalMb = memInfo.totalMem / 1_048_576L
+    val availMb = memInfo.availMem / 1_048_576L
+    val usedMb = totalMb - availMb
+
+    // Battery
+    val batteryIntent = context.registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
+    val level = batteryIntent?.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) ?: -1
+    val scale = batteryIntent?.getIntExtra(BatteryManager.EXTRA_SCALE, -1) ?: -1
+    val batteryPct = if (level >= 0 && scale > 0) (level * 100 / scale) else 0
+    val plugged = batteryIntent?.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1) ?: 0
+    val charging = plugged != 0
+
+    // Temperature (from battery broadcast - most reliable cross-device)
+    val rawTemp = batteryIntent?.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, 0) ?: 0
+    val tempC = rawTemp / 10f
+
+    return DeviceStats(
+        cpuPercent = cpu,
+        tempCelsius = tempC,
+        usedMemMb = usedMb,
+        totalMemMb = totalMb,
+        batteryPercent = batteryPct,
+        batteryCharging = charging,
+        videoFps = videoFps
+    )
+}
+
+/** Reads /proc/stat twice 100ms apart for a real CPU usage percentage. */
+private fun readCpuUsage(): Int {
+    return try {
+        fun readStat(): LongArray {
+            val line = BufferedReader(FileReader("/proc/stat")).use { it.readLine() } ?: return longArrayOf()
+            val parts = line.trim().split("\\s+".toRegex()).drop(1)
+            return parts.take(8).map { it.toLongOrNull() ?: 0L }.toLongArray()
+        }
+
+        val stat1 = readStat()
+        Thread.sleep(100)
+        val stat2 = readStat()
+        if (stat1.isEmpty() || stat2.isEmpty()) return 0
+
+        val idle1 = stat1.getOrElse(3) { 0L }
+        val idle2 = stat2.getOrElse(3) { 0L }
+        val total1 = stat1.sum()
+        val total2 = stat2.sum()
+
+        val totalDiff = total2 - total1
+        val idleDiff = idle2 - idle1
+        if (totalDiff <= 0) 0
+        else ((totalDiff - idleDiff) * 100L / totalDiff).toInt().coerceIn(0, 100)
+    } catch (_: Exception) {
+        0
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/DoubleTapIndicator.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/DoubleTapIndicator.kt
new file mode 100644
index 000000000..c7fa67ac2
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/DoubleTapIndicator.kt
@@ -0,0 +1,169 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.indication
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.size
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.ripple
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Outline
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.Shape
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.dp
+import kotlin.time.Duration.Companion.milliseconds
+import app.gyrolet.mpvrx.exoplayer.core.model.DoubleTapGesture
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.TapGestureState
+
+@Composable
+fun DoubleTapIndicator(modifier: Modifier = Modifier, tapGestureState: TapGestureState) {
+    if (tapGestureState.seekMillis == 0L) return
+    Box(
+        modifier = modifier.fillMaxSize(),
+        contentAlignment = if (tapGestureState.seekMillis > 0) Alignment.CenterEnd else Alignment.CenterStart,
+    ) {
+        Box(
+            modifier = Modifier
+                .fillMaxHeight()
+                .fillMaxWidth(
+                    fraction = when (tapGestureState.doubleTapGesture) {
+                        DoubleTapGesture.PLAY_PAUSE -> 0f
+                        DoubleTapGesture.FAST_FORWARD_AND_REWIND -> 0.5f
+                        DoubleTapGesture.BOTH -> 0.35f
+                        DoubleTapGesture.NONE -> 0f
+                    },
+                )
+                .clip(if (tapGestureState.seekMillis > 0) RightSideOvalShape() else LeftSideOvalShape())
+                .background(Color.White.copy(0.2f))
+                .indication(tapGestureState.interactionSource, ripple()),
+            contentAlignment = Alignment.Center,
+        ) {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+            ) {
+                DoubleTapSeekTriangles(isForward = tapGestureState.seekMillis > 0)
+                Text(
+                    text = "%+ds".format(tapGestureState.seekMillis.milliseconds.inWholeSeconds),
+                    style = MaterialTheme.typography.labelMedium,
+                    color = Color.White,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun DoubleTapSeekTriangles(
+    isForward: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    val animationDuration = 750L
+
+    val alpha1 = remember { Animatable(0f) }
+    val alpha2 = remember { Animatable(0f) }
+    val alpha3 = remember { Animatable(0f) }
+
+    LaunchedEffect(animationDuration) {
+        while (true) {
+            alpha1.animateTo(1f, animationSpec = tween((animationDuration / 5).toInt()))
+            alpha2.animateTo(1f, animationSpec = tween((animationDuration / 5).toInt()))
+            alpha3.animateTo(1f, animationSpec = tween((animationDuration / 5).toInt()))
+            alpha1.animateTo(0f, animationSpec = tween((animationDuration / 5).toInt()))
+            alpha2.animateTo(0f, animationSpec = tween((animationDuration / 5).toInt()))
+            alpha3.animateTo(0f, animationSpec = tween((animationDuration / 5).toInt()))
+        }
+    }
+
+    val rotation = if (isForward) 0f else 180f
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = modifier.rotate(rotation),
+    ) {
+        DoubleTapArrow(alpha1.value)
+        DoubleTapArrow(alpha2.value)
+        DoubleTapArrow(alpha3.value)
+    }
+}
+
+private class RightSideOvalShape : Shape {
+    override fun createOutline(
+        size: Size,
+        layoutDirection: LayoutDirection,
+        density: Density,
+    ): Outline {
+        val path = Path().apply {
+            moveTo(size.width, size.height)
+            lineTo(size.width, 0f)
+            lineTo(size.width * 0.1f, 0f)
+            cubicTo(
+                size.width * 0.1f,
+                0f,
+                -size.width * 0.1f,
+                size.height / 2,
+                size.width * 0.1f,
+                size.height,
+            )
+            close()
+        }
+        return Outline.Generic(path)
+    }
+}
+
+private class LeftSideOvalShape : Shape {
+    override fun createOutline(
+        size: Size,
+        layoutDirection: LayoutDirection,
+        density: Density,
+    ): Outline {
+        val path = Path().apply {
+            moveTo(0f, 0f)
+            lineTo(size.width * 0.9f, 0f)
+            cubicTo(
+                size.width * 0.9f,
+                0f,
+                size.width * 1.1f,
+                size.height / 2,
+                size.width * 0.9f,
+                size.height,
+            )
+            lineTo(0f, size.height)
+            close()
+        }
+        return Outline.Generic(path)
+    }
+}
+
+@Composable
+private fun DoubleTapArrow(alpha: Float) {
+    Icon(
+        imageVector = NextIcons.Play,
+        contentDescription = null,
+        modifier = Modifier
+            .size(20.dp)
+            .graphicsLayer { this.alpha = alpha },
+        tint = Color.White,
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/ExoPlayerControls.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/ExoPlayerControls.kt
new file mode 100644
index 000000000..9291e0220
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/ExoPlayerControls.kt
@@ -0,0 +1,521 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.WindowInsetsSides
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.only
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.windowInsetsPadding
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.BorderStroke
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.Surface
+import androidx.compose.material3.ripple
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.collectAsState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.draw.clip
+import androidx.constraintlayout.compose.ConstraintLayout
+import androidx.constraintlayout.compose.Dimension
+import androidx.media3.common.Player
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.feature.player.PlayerViewModel
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.ControlsVisibilityState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.MediaPresentationState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SeekGestureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.VideoZoomAndContentScaleState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.MetadataState
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.preferences.AppearancePreferences
+import app.gyrolet.mpvrx.preferences.PlayerButton
+import app.gyrolet.mpvrx.preferences.preference.collectAsState
+import app.gyrolet.mpvrx.ui.player.controls.components.SeekbarWithTimers
+import app.gyrolet.mpvrx.ui.player.controls.components.ControlsButton
+import app.gyrolet.mpvrx.ui.player.controls.components.AnimatedPlayPauseIcon
+import app.gyrolet.mpvrx.ui.player.controls.components.SlideToUnlock
+import app.gyrolet.mpvrx.ui.player.controls.playerControlsExitAnimationSpec
+import app.gyrolet.mpvrx.ui.player.controls.playerControlsEnterAnimationSpec
+import app.gyrolet.mpvrx.ui.player.controls.LocalPlayerButtonsClickEvent
+import app.gyrolet.mpvrx.ui.icons.Icons
+import app.gyrolet.mpvrx.ui.icons.Icon as AppSymbolIcon
+import app.gyrolet.mpvrx.ui.theme.spacing
+import app.gyrolet.mpvrx.ui.theme.controlColor
+import kotlinx.collections.immutable.persistentListOf
+import org.koin.compose.koinInject
+import app.gyrolet.mpvrx.exoplayer.feature.player.buttons.NextButton
+import app.gyrolet.mpvrx.exoplayer.feature.player.buttons.PreviousButton
+
+@Composable
+fun ExoPlayerControls(
+    player: Player,
+    viewModel: PlayerViewModel,
+    controlsVisibilityState: ControlsVisibilityState,
+    metadataState: MetadataState,
+    mediaPresentationState: MediaPresentationState,
+    seekGestureState: SeekGestureState,
+    videoZoomAndContentScaleState: VideoZoomAndContentScaleState,
+    playerPreferences: PlayerPreferences,
+    onBackClick: () -> Unit,
+    onOpenOverlay: (OverlayView) -> Unit,
+    onScreenshotClick: () -> Unit,
+    onPlayInBackgroundClick: () -> Unit,
+    onRotateClick: () -> Unit,
+    onPipClick: () -> Unit,
+    onAspectRatioClick: () -> Unit,
+    onVideoFiltersClick: () -> Unit,
+    onAmbienceModeClick: () -> Unit,
+    isAmbienceModeEnabled: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    val appearancePreferences = koinInject<AppearancePreferences>()
+    val spacing = MaterialTheme.spacing
+    val configuration = LocalConfiguration.current
+    val isPortrait = configuration.orientation == android.content.res.Configuration.ORIENTATION_PORTRAIT
+    
+    val hideBackground by appearancePreferences.hidePlayerButtonsBackground.collectAsState()
+    val topRightControlsPref by appearancePreferences.topRightControls.collectAsState()
+    val bottomRightControlsPref by appearancePreferences.bottomRightControls.collectAsState()
+    val bottomLeftControlsPref by appearancePreferences.bottomLeftControls.collectAsState()
+    val portraitBottomControlsPref by appearancePreferences.portraitBottomControls.collectAsState()
+
+    val (topRightButtons, bottomRightButtons, bottomLeftButtons) =
+        remember(topRightControlsPref, bottomRightControlsPref, bottomLeftControlsPref) {
+            val usedButtons = mutableSetOf<PlayerButton>()
+            val topR = appearancePreferences.parseButtons(topRightControlsPref, usedButtons)
+            val bottomR = appearancePreferences.parseButtons(bottomRightControlsPref, usedButtons)
+            val bottomL = appearancePreferences.parseButtons(bottomLeftControlsPref, usedButtons)
+            Triple(topR, bottomR, bottomL)
+        }
+
+    val portraitBottomButtons = remember(portraitBottomControlsPref) {
+        appearancePreferences.parseButtons(portraitBottomControlsPref, mutableSetOf())
+    }
+
+    val transparentOverlay by animateFloatAsState(
+        if (controlsVisibilityState.isControlsVisible && !controlsVisibilityState.isControlsLocked) 0.8f else 0f,
+        animationSpec = playerControlsExitAnimationSpec(),
+        label = "controls_transparent_overlay",
+    )
+
+    Box(modifier = modifier.fillMaxSize()) {
+        ConstraintLayout(
+            modifier = Modifier
+                .fillMaxSize()
+                .background(
+                    Brush.verticalGradient(
+                        Pair(0f, Color.Black),
+                        Pair(0.4f, Color.Transparent),
+                        Pair(0.6f, Color.Transparent),
+                        Pair(1f, Color.Black),
+                    ),
+                    alpha = transparentOverlay,
+                )
+                .windowInsetsPadding(WindowInsets.safeDrawing.only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal))
+        ) {
+            val (topLeft, topRight, centerControls, bottomControls, seekbarRef, unlockBtn) = createRefs()
+
+            // Top Left
+            AnimatedVisibility(
+                visible = controlsVisibilityState.isControlsVisible && !controlsVisibilityState.isControlsLocked,
+                enter = fadeIn(playerControlsEnterAnimationSpec()),
+                exit = fadeOut(playerControlsExitAnimationSpec()),
+                modifier = Modifier.constrainAs(topLeft) {
+                    top.linkTo(parent.top, spacing.medium)
+                    start.linkTo(parent.start, spacing.large)
+                    end.linkTo(topRight.start, spacing.medium)
+                    width = Dimension.fillToConstraints
+                }
+            ) {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(spacing.small)
+                ) {
+                    ControlsButton(
+                        icon = Icons.Default.ArrowBack,
+                        onClick = onBackClick,
+                        color = if (hideBackground) controlColor else MaterialTheme.colorScheme.onSurface,
+                        modifier = Modifier.size(45.dp)
+                    )
+                    
+                    Surface(
+                        shape = CircleShape,
+                        color = if (hideBackground) Color.Transparent else MaterialTheme.colorScheme.surfaceContainer.copy(alpha = 0.55f),
+                        contentColor = if (hideBackground) controlColor else MaterialTheme.colorScheme.onSurface,
+                        border = if (hideBackground) null else BorderStroke(1.dp, MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.4f)),
+                        modifier = Modifier.height(45.dp).clickable { onOpenOverlay(OverlayView.PLAYLIST) }
+                    ) {
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
+                            modifier = Modifier.padding(horizontal = 16.dp)
+                        ) {
+                            Text(
+                                text = metadataState.title ?: "",
+                                style = MaterialTheme.typography.bodyMedium,
+                                maxLines = 1,
+                                overflow = TextOverflow.Ellipsis,
+                                modifier = Modifier.weight(1f, fill = false)
+                            )
+                        }
+                    }
+                }
+            }
+
+            // Top Right
+            AnimatedVisibility(
+                visible = controlsVisibilityState.isControlsVisible && !controlsVisibilityState.isControlsLocked && !isPortrait,
+                enter = fadeIn(playerControlsEnterAnimationSpec()),
+                exit = fadeOut(playerControlsExitAnimationSpec()),
+                modifier = Modifier.constrainAs(topRight) {
+                    top.linkTo(parent.top, spacing.medium)
+                    end.linkTo(parent.end, spacing.large)
+                }
+            ) {
+                Row(horizontalArrangement = Arrangement.spacedBy(spacing.extraSmall)) {
+                    topRightButtons.forEach { button ->
+                        RenderExoPlayerButton(
+                            button = button,
+                            player = player,
+                            viewModel = viewModel,
+                            controlsVisibilityState = controlsVisibilityState,
+                            mediaPresentationState = mediaPresentationState,
+                            onOpenOverlay = onOpenOverlay,
+                            onScreenshotClick = onScreenshotClick,
+                            onPlayInBackgroundClick = onPlayInBackgroundClick,
+                            onRotateClick = onRotateClick,
+                            onPipClick = onPipClick,
+                            onAspectRatioClick = onAspectRatioClick,
+                            onVideoFiltersClick = onVideoFiltersClick,
+                            onAmbienceModeClick = onAmbienceModeClick,
+                            isAmbienceModeEnabled = isAmbienceModeEnabled,
+                            hideBackground = hideBackground,
+                            playerPreferences = playerPreferences
+                        )
+                    }
+                }
+            }
+
+            // Center Controls
+            AnimatedVisibility(
+                visible = controlsVisibilityState.isControlsVisible && !controlsVisibilityState.isControlsLocked,
+                enter = fadeIn(playerControlsEnterAnimationSpec()),
+                exit = fadeOut(playerControlsExitAnimationSpec()),
+                modifier = Modifier.constrainAs(centerControls) {
+                    centerTo(parent)
+                }
+            ) {
+                Row(
+                    horizontalArrangement = Arrangement.spacedBy(32.dp),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    PreviousButton(player = player)
+                    
+                    Surface(
+                        modifier = Modifier
+                            .size(72.dp)
+                            .clip(CircleShape)
+                            .clickable(
+                                interactionSource = remember { MutableInteractionSource() },
+                                indication = ripple(),
+                                onClick = { if (player.isPlaying) player.pause() else player.play() }
+                            ),
+                        shape = CircleShape,
+                        color = MaterialTheme.colorScheme.surfaceContainer.copy(alpha = 0.55f),
+                        contentColor = Color.White,
+                        border = BorderStroke(1.dp, MaterialTheme.colorScheme.outlineVariant.copy(alpha = 0.4f))
+                    ) {
+                        AnimatedPlayPauseIcon(
+                            isPlaying = mediaPresentationState.isPlaying,
+                            modifier = Modifier.fillMaxSize().padding(16.dp)
+                        )
+                    }
+
+                    NextButton(player = player)
+                }
+            }
+
+            // Seekbar
+            AnimatedVisibility(
+                visible = controlsVisibilityState.isControlsVisible && !controlsVisibilityState.isControlsLocked,
+                enter = fadeIn(playerControlsEnterAnimationSpec()),
+                exit = fadeOut(playerControlsExitAnimationSpec()),
+                modifier = Modifier.constrainAs(seekbarRef) {
+                    if (isPortrait) {
+                        bottom.linkTo(centerControls.top, spacing.large)
+                    } else {
+                        bottom.linkTo(bottomControls.top, spacing.medium)
+                    }
+                    start.linkTo(parent.start, spacing.large)
+                    end.linkTo(parent.end, spacing.large)
+                }
+            ) {
+                SeekbarWithTimers(
+                    position = (seekGestureState.pendingSeekPosition ?: mediaPresentationState.position).toFloat(),
+                    duration = mediaPresentationState.duration.toFloat(),
+                    onValueChange = { seekGestureState.onSeek(it.toLong()) },
+                    onValueChangeFinished = { seekGestureState.onSeekEnd() },
+                    timersInverted = Pair(false, false),
+                    positionTimerOnClick = {},
+                    durationTimerOnCLick = {},
+                    chapters = persistentListOf(),
+                    skipSegments = persistentListOf(),
+                    paused = !mediaPresentationState.isPlaying,
+                    isPortrait = isPortrait
+                )
+            }
+
+            // Bottom Controls
+            AnimatedVisibility(
+                visible = controlsVisibilityState.isControlsVisible && !controlsVisibilityState.isControlsLocked,
+                enter = fadeIn(playerControlsEnterAnimationSpec()),
+                exit = fadeOut(playerControlsExitAnimationSpec()),
+                modifier = Modifier.constrainAs(bottomControls) {
+                    bottom.linkTo(parent.bottom, spacing.large)
+                    start.linkTo(parent.start, spacing.large)
+                    end.linkTo(parent.end, spacing.large)
+                    width = Dimension.fillToConstraints
+                }
+            ) {
+                if (isPortrait) {
+                    Row(
+                        modifier = Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()),
+                        horizontalArrangement = Arrangement.spacedBy(spacing.medium, Alignment.CenterHorizontally)
+                    ) {
+                        portraitBottomButtons.forEach { button ->
+                            RenderExoPlayerButton(
+                                button = button,
+                                player = player,
+                                viewModel = viewModel,
+                                controlsVisibilityState = controlsVisibilityState,
+                                mediaPresentationState = mediaPresentationState,
+                                onOpenOverlay = onOpenOverlay,
+                                onScreenshotClick = onScreenshotClick,
+                                onPlayInBackgroundClick = onPlayInBackgroundClick,
+                                onRotateClick = onRotateClick,
+                                onPipClick = onPipClick,
+                                onAspectRatioClick = onAspectRatioClick,
+                                onVideoFiltersClick = onVideoFiltersClick,
+                                onAmbienceModeClick = onAmbienceModeClick,
+                                isAmbienceModeEnabled = isAmbienceModeEnabled,
+                                hideBackground = hideBackground,
+                                playerPreferences = playerPreferences
+                            )
+                        }
+                    }
+                } else {
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Row(horizontalArrangement = Arrangement.spacedBy(spacing.extraSmall)) {
+                            bottomLeftButtons.forEach { button ->
+                                RenderExoPlayerButton(
+                                    button = button,
+                                    player = player,
+                                    viewModel = viewModel,
+                                    controlsVisibilityState = controlsVisibilityState,
+                                    mediaPresentationState = mediaPresentationState,
+                                    onOpenOverlay = onOpenOverlay,
+                                    onScreenshotClick = onScreenshotClick,
+                                    onPlayInBackgroundClick = onPlayInBackgroundClick,
+                                    onRotateClick = onRotateClick,
+                                    onPipClick = onPipClick,
+                                    onAspectRatioClick = onAspectRatioClick,
+                                    onVideoFiltersClick = onVideoFiltersClick,
+                                    onAmbienceModeClick = onAmbienceModeClick,
+                                    isAmbienceModeEnabled = isAmbienceModeEnabled,
+                                    hideBackground = hideBackground,
+                                    playerPreferences = playerPreferences
+                                )
+                            }
+                        }
+                        Row(horizontalArrangement = Arrangement.spacedBy(spacing.extraSmall)) {
+                            bottomRightButtons.forEach { button ->
+                                RenderExoPlayerButton(
+                                    button = button,
+                                    player = player,
+                                    viewModel = viewModel,
+                                    controlsVisibilityState = controlsVisibilityState,
+                                    mediaPresentationState = mediaPresentationState,
+                                    onOpenOverlay = onOpenOverlay,
+                                    onScreenshotClick = onScreenshotClick,
+                                    onPlayInBackgroundClick = onPlayInBackgroundClick,
+                                    onRotateClick = onRotateClick,
+                                    onPipClick = onPipClick,
+                                    onAspectRatioClick = onAspectRatioClick,
+                                    onVideoFiltersClick = onVideoFiltersClick,
+                                    onAmbienceModeClick = onAmbienceModeClick,
+                                    isAmbienceModeEnabled = isAmbienceModeEnabled,
+                                    hideBackground = hideBackground,
+                                    playerPreferences = playerPreferences
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Unlock Button
+            AnimatedVisibility(
+                visible = controlsVisibilityState.isControlsVisible && controlsVisibilityState.isControlsLocked,
+                enter = fadeIn(),
+                exit = fadeOut(),
+                modifier = Modifier.constrainAs(unlockBtn) {
+                    bottom.linkTo(parent.bottom, spacing.extraLarge)
+                    centerHorizontallyTo(parent)
+                }
+            ) {
+                SlideToUnlock(onUnlock = { controlsVisibilityState.unlockControls() })
+            }
+        }
+
+        // Stats Overlay
+        DeviceStatsOverlay(
+            visible = playerPreferences.statisticsPage == 1,
+            player = player,
+            onDismiss = { viewModel.updateStatisticsPage(0) },
+            modifier = Modifier.align(Alignment.TopStart).padding(16.dp)
+        )
+    }
+}
+
+@Composable
+fun RenderExoPlayerButton(
+    button: PlayerButton,
+    player: Player,
+    viewModel: PlayerViewModel,
+    controlsVisibilityState: ControlsVisibilityState,
+    mediaPresentationState: MediaPresentationState,
+    onOpenOverlay: (OverlayView) -> Unit,
+    onScreenshotClick: () -> Unit,
+    onPlayInBackgroundClick: () -> Unit,
+    onRotateClick: () -> Unit,
+    onPipClick: () -> Unit,
+    onAspectRatioClick: () -> Unit,
+    onVideoFiltersClick: () -> Unit,
+    onAmbienceModeClick: () -> Unit,
+    isAmbienceModeEnabled: Boolean,
+    hideBackground: Boolean,
+    playerPreferences: PlayerPreferences,
+) {
+    val color = if (hideBackground) controlColor else MaterialTheme.colorScheme.onSurface
+
+    when (button) {
+        PlayerButton.PLAYBACK_SPEED -> {
+            ControlsButton(icon = Icons.Default.Speed, onClick = { onOpenOverlay(OverlayView.PLAYBACK_SPEED) }, color = color)
+        }
+        PlayerButton.DECODER -> {
+            ControlsButton(icon = Icons.Default.DeveloperBoard, onClick = { onOpenOverlay(OverlayView.DECODER_PRIORITY) }, color = color)
+        }
+        PlayerButton.SCREEN_ROTATION -> {
+            ControlsButton(icon = Icons.Default.ScreenRotation, onClick = onRotateClick, color = color)
+        }
+        PlayerButton.FRAME_NAVIGATION -> {
+            ControlsButton(icon = Icons.Default.Screenshot, onClick = onScreenshotClick, color = color)
+        }
+        PlayerButton.VIDEO_ZOOM -> {
+            ControlsButton(icon = Icons.Default.ZoomIn, onClick = { onOpenOverlay(OverlayView.VIDEO_CONTENT_SCALE) }, color = color)
+        }
+        PlayerButton.PICTURE_IN_PICTURE -> {
+            ControlsButton(icon = Icons.Default.PictureInPictureAlt, onClick = onPipClick, color = color)
+        }
+        PlayerButton.ASPECT_RATIO -> {
+            ControlsButton(icon = Icons.Default.AspectRatio, onClick = onAspectRatioClick, color = color)
+        }
+        PlayerButton.LOCK_CONTROLS -> {
+            ControlsButton(icon = Icons.Default.LockOpen, onClick = { controlsVisibilityState.lockControls() }, color = color)
+        }
+        PlayerButton.AUDIO_TRACK -> {
+            ControlsButton(icon = Icons.Default.Audiotrack, onClick = { onOpenOverlay(OverlayView.AUDIO_SELECTOR) }, color = color)
+        }
+        PlayerButton.SUBTITLES -> {
+            ControlsButton(icon = Icons.Default.Subtitles, onClick = { onOpenOverlay(OverlayView.SUBTITLE_SELECTOR) }, color = color)
+        }
+        PlayerButton.REPEAT_MODE -> {
+            val icon = when (player.repeatMode) {
+                Player.REPEAT_MODE_OFF -> Icons.Filled.Repeat
+                Player.REPEAT_MODE_ONE -> Icons.Filled.RepeatOne
+                else -> Icons.Filled.Repeat
+            }
+            ControlsButton(icon = icon, onClick = {
+                player.repeatMode = when (player.repeatMode) {
+                    Player.REPEAT_MODE_OFF -> Player.REPEAT_MODE_ONE
+                    Player.REPEAT_MODE_ONE -> Player.REPEAT_MODE_ALL
+                    else -> Player.REPEAT_MODE_OFF
+                }
+            }, color = color)
+        }
+        PlayerButton.SHUFFLE -> {
+            ControlsButton(icon = if (player.shuffleModeEnabled) Icons.Default.ShuffleOn else Icons.Default.Shuffle, onClick = {
+                player.shuffleModeEnabled = !player.shuffleModeEnabled
+            }, color = color)
+        }
+        PlayerButton.BACKGROUND_PLAYBACK -> {
+            ControlsButton(icon = Icons.Default.Headset, onClick = onPlayInBackgroundClick, color = color)
+        }
+        PlayerButton.AMBIENT_MODE -> {
+            ControlsButton(icon = if (isAmbienceModeEnabled) Icons.Default.BlurOn else Icons.Default.BlurOff, onClick = onAmbienceModeClick, color = if (isAmbienceModeEnabled) MaterialTheme.colorScheme.primary else color)
+        }
+        PlayerButton.TIME_NETWORK -> {
+            ControlsButton(icon = Icons.Default.AccessTime, onClick = {
+                viewModel.updateStatisticsPage(if (playerPreferences.statisticsPage == 1) 0 else 1)
+            }, color = if (playerPreferences.statisticsPage == 1) MaterialTheme.colorScheme.primary else color)
+        }
+        PlayerButton.VIDEO_FILTERS -> {
+            ControlsButton(icon = Icons.Default.Tune, onClick = onVideoFiltersClick, color = color)
+        }
+        PlayerButton.MORE_OPTIONS -> {
+            ControlsButton(icon = Icons.Default.MoreVert, onClick = onVideoFiltersClick, onLongClick = { onOpenOverlay(OverlayView.VIDEO_FILTERS) }, color = color)
+        }
+        PlayerButton.HDR_MODE -> {
+            ControlsButton(icon = Icons.Default.HdrOn, onClick = {}, color = color)
+        }
+        PlayerButton.MIRROR -> {
+            ControlsButton(icon = Icons.Default.Flip, onClick = {}, color = color)
+        }
+        PlayerButton.VERTICAL_FLIP -> {
+            ControlsButton(icon = Icons.Default.Flip, onClick = {}, color = color) // Need a vertical flip icon ideally
+        }
+        PlayerButton.AB_LOOP -> {
+            ControlsButton(icon = Icons.Default.Repeat, onClick = {}, color = color)
+        }
+        PlayerButton.CUSTOM_SKIP -> {
+            ControlsButton(icon = Icons.Default.FastForward, onClick = {}, color = color)
+        }
+        PlayerButton.BOOKMARKS_CHAPTERS -> {
+            ControlsButton(icon = Icons.Default.Bookmarks, onClick = { onOpenOverlay(OverlayView.PLAYLIST) }, color = color)
+        }
+        PlayerButton.CURRENT_CHAPTER -> {
+            ControlsButton(icon = Icons.Default.Bookmarks, onClick = { onOpenOverlay(OverlayView.PLAYLIST) }, color = color)
+        }
+        else -> {}
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/MenuOverlayView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/MenuOverlayView.kt
new file mode 100644
index 000000000..3695b8316
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/MenuOverlayView.kt
@@ -0,0 +1,132 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.animation.togetherWith
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.calculateEndPadding
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.isPortrait
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+sealed interface MenuRoute {
+    data object Root : MenuRoute
+    data object SleepTimer : MenuRoute
+    data object Decoder : MenuRoute
+    data object PlaybackSpeed : MenuRoute
+    data object Audio : MenuRoute
+    data object Subtitle : MenuRoute
+    data object Playlist : MenuRoute
+    data object VideoContentScale : MenuRoute
+    data object VideoFilters : MenuRoute
+}
+
+@Composable
+fun BoxScope.MenuOverlayView(
+    externalRoute: MenuRoute?,
+    title: String,
+    canGoBack: Boolean,
+    onBack: () -> Unit,
+    content: @Composable (MenuRoute) -> Unit,
+) {
+    val configuration = LocalConfiguration.current
+    val layoutDirection = LocalLayoutDirection.current
+    val endPadding = WindowInsets.safeDrawing
+        .asPaddingValues()
+        .calculateEndPadding(layoutDirection)
+
+    AnimatedVisibility(
+        modifier = Modifier.align(
+            if (configuration.isPortrait) Alignment.BottomCenter else Alignment.CenterEnd,
+        ),
+        visible = externalRoute != null,
+        enter = if (configuration.isPortrait) slideInVertically { it } else slideInHorizontally { it },
+        exit = if (configuration.isPortrait) slideOutVertically { it } else slideOutHorizontally { it },
+    ) {
+        Surface(
+            shape = RoundedCornerShape(16.dp),
+            modifier = Modifier
+                .testTag("panel_player_menu")
+                .then(
+                    if (configuration.isPortrait) {
+                        Modifier.fillMaxWidth().fillMaxHeight(0.45f)
+                    } else {
+                        Modifier.fillMaxWidth(0.45f).fillMaxHeight()
+                    },
+                ),
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(top = 16.dp, bottom = 16.dp)
+                    .padding(end = endPadding),
+            ) {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(horizontal = 8.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    if (canGoBack) {
+                        IconButton(
+                            modifier = Modifier.testTag("btn_menu_back"),
+                            onClick = onBack,
+                        ) {
+                            Icon(
+                                imageVector = NextIcons.ArrowBack,
+                                contentDescription = stringResource(R.string.navigate_up),
+                            )
+                        }
+                    } else {
+                        Spacer(modifier = Modifier.size(8.dp))
+                    }
+                    Text(
+                        modifier = Modifier.padding(horizontal = 8.dp),
+                        text = title,
+                        style = MaterialTheme.typography.headlineSmall,
+                    )
+                }
+                Spacer(modifier = Modifier.size(8.dp))
+                AnimatedContent(
+                    targetState = externalRoute ?: MenuRoute.Root,
+                    transitionSpec = { fadeIn() togetherWith fadeOut() },
+                    label = "menu_route",
+                    modifier = Modifier.fillMaxSize(),
+                ) { route ->
+                    content(route)
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/MenuRootContent.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/MenuRootContent.kt
new file mode 100644
index 000000000..e2852dd3a
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/MenuRootContent.kt
@@ -0,0 +1,174 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@Composable
+fun MenuRootContent(
+    isLockEnabled: Boolean,
+    isPipSupported: Boolean,
+    isTakingScreenshot: Boolean,
+    onNavigate: (MenuRoute) -> Unit,
+    onLockClick: () -> Unit,
+    onAmbienceClick: () -> Unit,
+    onPictureInPictureClick: () -> Unit,
+    onScreenshotClick: () -> Unit,
+    onPlayInBackgroundClick: () -> Unit,
+    onLoopClick: () -> Unit,
+    onShuffleClick: () -> Unit,
+    onStatsClick: () -> Unit,
+) {
+    Column(
+        modifier = Modifier
+            .verticalScroll(rememberScrollState())
+            .padding(bottom = 24.dp)
+            .padding(horizontal = 16.dp),
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+        MenuItemRow(
+            icon = NextIcons.BugReport,
+            text = stringResource(R.string.player_sheets_stats_page_title),
+            testTag = "menu_item_stats",
+            onClick = onStatsClick,
+        )
+        MenuItemRow(
+            icon = NextIcons.Subtitle,
+            text = stringResource(R.string.select_subtitle_track),
+            testTag = "menu_item_subtitle",
+            onClick = { onNavigate(MenuRoute.Subtitle) },
+        )
+        MenuItemRow(
+            icon = NextIcons.Audio,
+            text = stringResource(R.string.select_audio_track),
+            testTag = "menu_item_audio",
+            onClick = { onNavigate(MenuRoute.Audio) },
+        )
+        MenuItemRow(
+            icon = NextIcons.Frame,
+            text = stringResource(R.string.video_zoom),
+            testTag = "menu_item_video_scale",
+            onClick = { onNavigate(MenuRoute.VideoContentScale) },
+        )
+        MenuItemRow(
+            icon = NextIcons.Decoder,
+            text = stringResource(R.string.decoder_priority),
+            testTag = "menu_item_decoder",
+            onClick = { onNavigate(MenuRoute.Decoder) },
+        )
+        MenuItemRow(
+            icon = NextIcons.Sensitivity,
+            text = stringResource(R.string.video_filters),
+            testTag = "menu_item_video_filters",
+            onClick = { onNavigate(MenuRoute.VideoFilters) },
+        )
+        MenuItemRow(
+            icon = NextIcons.Timer,
+            text = stringResource(R.string.exo_sleep_timer),
+            testTag = "menu_item_sleep_timer",
+            onClick = { onNavigate(MenuRoute.SleepTimer) },
+        )
+        MenuItemRow(
+            icon = NextIcons.Lock,
+            text = stringResource(if (isLockEnabled) R.string.controls_unlock else R.string.controls_lock),
+            testTag = "menu_item_lock",
+            onClick = onLockClick,
+        )
+        MenuItemRow(
+            icon = NextIcons.Style,
+            text = stringResource(R.string.ambience_mode),
+            testTag = "menu_item_ambience",
+            onClick = onAmbienceClick,
+        )
+        if (isPipSupported) {
+            MenuItemRow(
+                icon = NextIcons.Pip,
+                text = stringResource(R.string.pip_settings),
+                testTag = "menu_item_pip",
+                onClick = onPictureInPictureClick,
+            )
+        }
+        MenuItemRow(
+            icon = NextIcons.Screenshot,
+            text = stringResource(R.string.take_screenshot),
+            testTag = "menu_item_screenshot",
+            onClick = onScreenshotClick,
+            isEnabled = !isTakingScreenshot,
+        )
+        MenuItemRow(
+            icon = NextIcons.Headset,
+            text = stringResource(R.string.background_play),
+            testTag = "menu_item_background",
+            onClick = onPlayInBackgroundClick,
+        )
+        MenuItemRow(
+            icon = NextIcons.Loop,
+            text = stringResource(R.string.loop_mode),
+            testTag = "menu_item_loop",
+            onClick = onLoopClick,
+        )
+        MenuItemRow(
+            icon = NextIcons.Shuffle,
+            text = stringResource(R.string.shuffle),
+            testTag = "menu_item_shuffle",
+            onClick = onShuffleClick,
+        )
+    }
+}
+
+@Composable
+private fun MenuItemRow(
+    icon: AppIcon,
+    text: String,
+    testTag: String,
+    onClick: () -> Unit,
+    isEnabled: Boolean = true,
+) {
+    Surface(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(RoundedCornerShape(12.dp))
+            .testTag(testTag),
+        onClick = onClick,
+        enabled = isEnabled,
+        color = MaterialTheme.colorScheme.surface,
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 12.dp, vertical = 12.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.onSurface,
+            )
+            Text(
+                text = text,
+                style = MaterialTheme.typography.bodyLarge,
+                modifier = Modifier.weight(1f),
+            )
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/OverlayShowView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/OverlayShowView.kt
new file mode 100644
index 000000000..affc72d89
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/OverlayShowView.kt
@@ -0,0 +1,139 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import android.content.res.Configuration
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.media3.common.Player
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.VideoContentScale
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.noRippleClickable
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SleepTimerState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SubtitleOptionsEvent
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.VideoFiltersPanel
+
+@Composable
+fun BoxScope.OverlayShowView(
+    player: Player,
+    overlayView: OverlayView?,
+    videoContentScale: VideoContentScale,
+    playerPreferences: PlayerPreferences,
+    sleepTimerState: SleepTimerState,
+    onDismiss: () -> Unit = {},
+    onSelectSubtitleClick: () -> Unit = {},
+    onAddOnlineSubtitleClick: (String) -> Unit = {},
+    onSubtitleOptionEvent: (SubtitleOptionsEvent) -> Unit = {},
+    onSubtitleStyleChanged: (PlayerPreferences) -> Unit = {},
+    onVideoContentScaleChanged: (VideoContentScale) -> Unit = {},
+    onPreviewVideoFilters: (PlayerPreferences) -> Unit = {},
+    onConfirmVideoFilters: (PlayerPreferences) -> Unit = {},
+    onCloseVideoFilters: () -> Unit = {},
+    onShowVideoFilters: () -> Unit = {},
+    onDecoderPriorityChanged: (DecoderPriority) -> Unit = {},
+) {
+    Box(
+        modifier = Modifier
+            .matchParentSize()
+            .then(
+                if (overlayView != null) {
+                    Modifier.noRippleClickable(onClick = onDismiss)
+                } else {
+                    Modifier
+                },
+            ),
+    )
+
+    AudioTrackSelectorView(
+        shouldShow = overlayView == OverlayView.AUDIO_SELECTOR,
+        player = player,
+        onDismiss = onDismiss,
+    )
+
+    SubtitleSelectorView(
+        shouldShow = overlayView == OverlayView.SUBTITLE_SELECTOR,
+        player = player,
+        onSelectSubtitleClick = onSelectSubtitleClick,
+        onAddOnlineSubtitleClick = onAddOnlineSubtitleClick,
+        preferences = playerPreferences,
+        onPreferencesChange = onSubtitleStyleChanged,
+        onEvent = onSubtitleOptionEvent,
+        onDismiss = onDismiss,
+    )
+
+    PlaybackSpeedSelectorView(
+        shouldShow = overlayView == OverlayView.PLAYBACK_SPEED,
+        player = player,
+    )
+
+    VideoContentScaleSelectorView(
+        shouldShow = overlayView == OverlayView.VIDEO_CONTENT_SCALE,
+        videoContentScale = videoContentScale,
+        onVideoContentScaleChanged = onVideoContentScaleChanged,
+        onShowVideoFilters = onShowVideoFilters,
+        onDismiss = onDismiss,
+    )
+
+    VideoFilterOverlayView(
+        shouldShow = overlayView == OverlayView.VIDEO_FILTERS,
+        preferences = playerPreferences,
+        onDismissRequest = onCloseVideoFilters,
+        onPreviewPreferences = onPreviewVideoFilters,
+        onConfirmPreferences = onConfirmVideoFilters,
+    )
+
+    PlaylistView(
+        shouldShow = overlayView == OverlayView.PLAYLIST,
+        player = player,
+    )
+
+    SleepTimerSelectorView(
+        shouldShow = overlayView == OverlayView.SLEEP_TIMER,
+        sleepTimerState = sleepTimerState,
+        onDismiss = onDismiss,
+    )
+
+    DecoderPrioritySelectorView(
+        shouldShow = overlayView == OverlayView.DECODER_PRIORITY,
+        currentDecoderPriority = playerPreferences.decoderPriority,
+        onDecoderPriorityClick = onDecoderPriorityChanged,
+        onDismiss = onDismiss,
+    )
+}
+
+@Composable
+private fun BoxScope.VideoFilterOverlayView(
+    shouldShow: Boolean,
+    preferences: PlayerPreferences,
+    onDismissRequest: () -> Unit,
+    onPreviewPreferences: (PlayerPreferences) -> Unit,
+    onConfirmPreferences: (PlayerPreferences) -> Unit,
+) {
+    OverlayView(
+        shouldShow = shouldShow,
+        title = stringResource(R.string.video_filters),
+        testTag = "panel_video_filters",
+    ) {
+        VideoFiltersPanel(
+            preferences = preferences,
+            onDismissRequest = onDismissRequest,
+            onPreviewPreferences = onPreviewPreferences,
+            onConfirmPreferences = onConfirmPreferences,
+        )
+    }
+}
+
+enum class OverlayView {
+    AUDIO_SELECTOR,
+    SUBTITLE_SELECTOR,
+    PLAYBACK_SPEED,
+    VIDEO_CONTENT_SCALE,
+    VIDEO_FILTERS,
+    PLAYLIST,
+    SLEEP_TIMER,
+    DECODER_PRIORITY,
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/OverlayView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/OverlayView.kt
new file mode 100644
index 000000000..a600ad8e8
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/OverlayView.kt
@@ -0,0 +1,108 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.calculateEndPadding
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawing
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.isPortrait
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.withBottomFallback
+
+@Composable
+fun BoxScope.OverlayView(
+    modifier: Modifier = Modifier,
+    shouldShow: Boolean,
+    title: String,
+    testTag: String? = null,
+    contentPadding: PaddingValues = PaddingValues(),
+    content: @Composable ColumnScope.() -> Unit,
+) {
+    val configuration = LocalConfiguration.current
+    val resolvedContentPadding = contentPadding.withBottomFallback()
+    val layoutDirection = LocalLayoutDirection.current
+    val endPadding = WindowInsets.safeDrawing
+        .asPaddingValues()
+        .calculateEndPadding(layoutDirection)
+
+    AnimatedVisibility(
+        modifier = Modifier.align(
+            if (configuration.isPortrait) {
+                Alignment.BottomCenter
+            } else {
+                Alignment.CenterEnd
+            },
+        ),
+        visible = shouldShow,
+        enter = if (configuration.isPortrait) slideInVertically { it } else slideInHorizontally { it },
+        exit = if (configuration.isPortrait) slideOutVertically { it } else slideOutHorizontally { it },
+    ) {
+        Surface(
+            shape = RoundedCornerShape(16.dp),
+            modifier = modifier
+                .then(
+                    if (testTag != null) {
+                        Modifier
+                            .testTag(testTag)
+                            .semantics { contentDescription = testTag }
+                    } else {
+                        Modifier
+                    },
+                )
+                .then(
+                    if (configuration.isPortrait) {
+                        Modifier
+                            .fillMaxWidth()
+                            .fillMaxHeight(0.45f)
+                    } else {
+                        Modifier
+                            .fillMaxWidth(0.45f)
+                            .fillMaxHeight()
+                    },
+                ),
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(resolvedContentPadding)
+                    .padding(top = 24.dp)
+                    .padding(end = endPadding),
+            ) {
+                Text(
+                    modifier = Modifier.padding(horizontal = 24.dp),
+                    text = title,
+                    style = MaterialTheme.typography.headlineSmall,
+                )
+                Spacer(modifier = Modifier.size(8.dp))
+                content()
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/PlaybackSpeedSelectorView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/PlaybackSpeedSelectorView.kt
new file mode 100644
index 000000000..b95b8fb8a
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/PlaybackSpeedSelectorView.kt
@@ -0,0 +1,186 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.annotation.OptIn
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.toggleable
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LocalContentColor
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.round
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberPlaybackParametersState
+
+@OptIn(UnstableApi::class)
+@Composable
+fun BoxScope.PlaybackSpeedSelectorView(
+    modifier: Modifier = Modifier,
+    shouldShow: Boolean,
+    player: Player,
+) {
+    OverlayView(
+        modifier = modifier,
+        shouldShow = shouldShow,
+        title = stringResource(R.string.select_playback_speed),
+    ) {
+        PlaybackSpeedSelectorContent(player = player)
+    }
+}
+
+@OptIn(UnstableApi::class)
+@Composable
+fun PlaybackSpeedSelectorContent(player: Player) {
+    val hapticFeedback = LocalHapticFeedback.current
+    val playbackParametersState = rememberPlaybackParametersState(player)
+    Column(
+        modifier = Modifier
+            .verticalScroll(rememberScrollState())
+            .padding(bottom = 24.dp)
+            .padding(horizontal = 24.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        val minValue = 0.2f
+        val maxValue = 4.0f
+        val stepSize = 0.01f
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            FilledTonalIconButton(
+                onClick = {
+                    val newSpeed =
+                        (playbackParametersState.speed - stepSize).coerceAtLeast(minValue).round(2)
+                    playbackParametersState.setPlaybackSpeed(newSpeed)
+                },
+            ) {
+                Icon(
+                    painter = painterResource(R.drawable.ic_remove),
+                    contentDescription = null,
+                )
+            }
+
+            Text(
+                text = playbackParametersState.speed.round(2).toString(),
+                style = MaterialTheme.typography.titleMedium,
+                textAlign = TextAlign.Center,
+                modifier = Modifier.weight(1f),
+            )
+
+            FilledTonalIconButton(
+                onClick = {
+                    val newSpeed = (playbackParametersState.speed + stepSize).coerceAtMost(maxValue).round(2)
+                    playbackParametersState.setPlaybackSpeed(newSpeed)
+                },
+            ) {
+                Icon(
+                    painter = painterResource(R.drawable.ic_add),
+                    contentDescription = null,
+                )
+            }
+        }
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Slider(
+                value = playbackParametersState.speed,
+                valueRange = minValue..maxValue,
+                onValueChange = {
+                    hapticFeedback.performHapticFeedback(HapticFeedbackType.TextHandleMove)
+                    playbackParametersState.setPlaybackSpeed(it.round(2))
+                },
+                modifier = Modifier.weight(1f),
+            )
+            IconButton(onClick = { playbackParametersState.setPlaybackSpeed(1f) }) {
+                Icon(
+                    painter = painterResource(R.drawable.ic_reset),
+                    contentDescription = null,
+                )
+            }
+        }
+        FlowRow(
+            maxItemsInEachRow = 5,
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            listOf(
+                0.2f, 0.5f, 0.75f, 1.0f, 1.5f, 2.0f, 2.5f, 3.0f, 3.5f, 4.0f,
+            ).forEach { speed ->
+                Box(
+                    modifier = Modifier
+                        .clip(CircleShape)
+                        .border(
+                            width = 1.dp,
+                            color = LocalContentColor.current,
+                            shape = CircleShape,
+                        )
+                        .clickable { playbackParametersState.setPlaybackSpeed(speed) }
+                        .padding(
+                            horizontal = 8.dp,
+                            vertical = 8.dp,
+                        )
+                        .weight(1f),
+                    contentAlignment = Alignment.Center,
+                ) {
+                    Text(
+                        text = speed.toString(),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.primary,
+                    )
+                }
+            }
+        }
+
+        Row(
+            modifier = Modifier
+                .clip(RoundedCornerShape(4.dp))
+                .toggleable(
+                    value = playbackParametersState.isSkipSilenceEnabled,
+                    onValueChange = { playbackParametersState.setIsSkipSilenceEnabled(it) },
+                )
+                .fillMaxWidth()
+                .padding(8.dp)
+                .semantics(mergeDescendants = true) {},
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            Text(
+                text = stringResource(R.string.skip_silence),
+                style = MaterialTheme.typography.bodyLarge,
+                modifier = Modifier.weight(1f),
+            )
+            Switch(
+                checked = playbackParametersState.isSkipSilenceEnabled,
+                onCheckedChange = null,
+            )
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/PlayerGestures.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/PlayerGestures.kt
new file mode 100644
index 000000000..5151ac5b3
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/PlayerGestures.kt
@@ -0,0 +1,172 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.gestures.awaitLongPressOrCancellation
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.testTag
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.detectCustomHorizontalDragGestures
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.detectCustomTransformGestures
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.detectCustomVerticalDragGestures
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.ControlsVisibilityState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.PictureInPictureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SeekGestureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.TapGestureState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.VideoZoomAndContentScaleState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.VolumeAndBrightnessGestureState
+
+@Composable
+fun PlayerGestures(
+    modifier: Modifier = Modifier,
+    controlsVisibilityState: ControlsVisibilityState,
+    tapGestureState: TapGestureState,
+    pictureInPictureState: PictureInPictureState,
+    seekGestureState: SeekGestureState,
+    videoZoomAndContentScaleState: VideoZoomAndContentScaleState,
+    volumeAndBrightnessGestureState: VolumeAndBrightnessGestureState,
+    isEnabled: Boolean = true,
+) {
+    BoxWithConstraints {
+        Box(
+            modifier = modifier
+                .fillMaxSize()
+                .testTag("player_gesture_surface")
+                .pointerInput(
+                    isEnabled,
+                    controlsVisibilityState.isControlsLocked,
+                    pictureInPictureState.isInPictureInPictureMode,
+                ) {
+                    if (!isEnabled) return@pointerInput
+                    if (controlsVisibilityState.isControlsLocked) return@pointerInput
+                    if (pictureInPictureState.isInPictureInPictureMode) return@pointerInput
+
+                    awaitEachGesture {
+                        val down = awaitFirstDown(requireUnconsumed = false)
+                        val longPress = awaitLongPressOrCancellation(down.id) ?: return@awaitEachGesture
+
+                        tapGestureState.handleLongPress()
+                        if (!tapGestureState.isLongPressGestureInAction) return@awaitEachGesture
+
+                        try {
+                            longPress.consume()
+                            var pointerId = longPress.id
+                            while (true) {
+                                val event = awaitPointerEvent(pass = PointerEventPass.Initial)
+                                val change = event.changes.firstOrNull { it.id == pointerId }
+                                    ?: event.changes.firstOrNull()
+                                    ?: break
+
+                                pointerId = change.id
+                                if (!change.pressed) break
+
+                                val dragAmount = change.position.x - change.previousPosition.x
+                                if (dragAmount != 0f) {
+                                    change.consume()
+                                    tapGestureState.handleLongPressHorizontalDrag(dragAmount)
+                                }
+                            }
+                        } finally {
+                            tapGestureState.handleOnLongPressRelease()
+                        }
+                    }
+                }
+                .pointerInput(isEnabled, pictureInPictureState.isInPictureInPictureMode) {
+                    if (!isEnabled) return@pointerInput
+                    if (pictureInPictureState.isInPictureInPictureMode) return@pointerInput
+
+                    detectTapGestures(
+                        onTap = {
+                            if (tapGestureState.seekMillis != 0L) return@detectTapGestures
+                            controlsVisibilityState.toggleControlsVisibility()
+                        },
+                        onDoubleTap = {
+                            if (controlsVisibilityState.isControlsLocked) return@detectTapGestures
+                            tapGestureState.handleDoubleTap(offset = it, size = size)
+                        },
+                    )
+                }
+                .pointerInput(
+                    isEnabled,
+                    controlsVisibilityState.isControlsLocked,
+                    pictureInPictureState.isInPictureInPictureMode,
+                ) {
+                    if (!isEnabled) return@pointerInput
+                    if (controlsVisibilityState.isControlsLocked) return@pointerInput
+                    if (pictureInPictureState.isInPictureInPictureMode) return@pointerInput
+
+                    detectCustomHorizontalDragGestures(
+                        onDragStart = {
+                            if (tapGestureState.isLongPressGestureCaptured) return@detectCustomHorizontalDragGestures
+                            seekGestureState.onDragStart(it)
+                            if (seekGestureState.isSeeking) {
+                                controlsVisibilityState.hideControls()
+                            }
+                        },
+                        onHorizontalDrag = { change, dragAmount ->
+                            if (tapGestureState.isLongPressGestureCaptured) {
+                                change.consume()
+                                return@detectCustomHorizontalDragGestures
+                            }
+                            seekGestureState.onDrag(change, dragAmount)
+                        },
+                        onDragCancel = {
+                            if (tapGestureState.isLongPressGestureCaptured) return@detectCustomHorizontalDragGestures
+                            seekGestureState.onDragEnd()
+                        },
+                        onDragEnd = {
+                            if (tapGestureState.isLongPressGestureCaptured) return@detectCustomHorizontalDragGestures
+                            seekGestureState.onDragEnd()
+                        },
+                    )
+                }
+                .pointerInput(
+                    isEnabled,
+                    controlsVisibilityState.isControlsLocked,
+                    pictureInPictureState.isInPictureInPictureMode,
+                    tapGestureState.isLongPressGestureInAction,
+                ) {
+                    if (!isEnabled) return@pointerInput
+                    if (controlsVisibilityState.isControlsLocked) return@pointerInput
+                    if (pictureInPictureState.isInPictureInPictureMode) return@pointerInput
+                    if (tapGestureState.isLongPressGestureInAction) return@pointerInput
+
+                    detectCustomVerticalDragGestures(
+                        onDragStart = { volumeAndBrightnessGestureState.onDragStart(it, size) },
+                        onVerticalDrag = volumeAndBrightnessGestureState::onDrag,
+                        onDragCancel = volumeAndBrightnessGestureState::onDragEnd,
+                        onDragEnd = volumeAndBrightnessGestureState::onDragEnd,
+                    )
+                }
+                .pointerInput(
+                    isEnabled,
+                    controlsVisibilityState.isControlsLocked,
+                    pictureInPictureState.isInPictureInPictureMode,
+                ) {
+                    if (!isEnabled) return@pointerInput
+                    if (controlsVisibilityState.isControlsLocked) return@pointerInput
+                    if (pictureInPictureState.isInPictureInPictureMode) return@pointerInput
+
+                    detectCustomTransformGestures(
+                        onGesture = { _, panChange, zoomChange, _ ->
+                            if (tapGestureState.isLongPressGestureInAction) return@detectCustomTransformGestures
+                            videoZoomAndContentScaleState.onZoomPanGesture(
+                                constraints = this@BoxWithConstraints.constraints,
+                                panChange = panChange,
+                                zoomChange = zoomChange,
+                            )
+                        },
+                        onGestureEnd = {
+                            videoZoomAndContentScaleState.onZoomPanGestureEnd()
+                        },
+                    )
+                },
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/PlaylistView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/PlaylistView.kt
new file mode 100644
index 000000000..fda86575d
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/PlaylistView.kt
@@ -0,0 +1,292 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.annotation.OptIn
+import androidx.compose.foundation.background
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.min
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import coil3.compose.AsyncImage
+import coil3.request.ImageRequest
+import coil3.request.crossfade
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.common.Utils
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextSegmentedListItem
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberPlaylistState
+import sh.calvin.reorderable.DragGestureDetector
+import sh.calvin.reorderable.ReorderableCollectionItemScope
+import sh.calvin.reorderable.ReorderableItem
+import sh.calvin.reorderable.rememberReorderableLazyListState
+
+@OptIn(UnstableApi::class)
+@Composable
+fun BoxScope.PlaylistView(
+    modifier: Modifier = Modifier,
+    shouldShow: Boolean,
+    player: Player,
+) {
+    OverlayView(
+        modifier = modifier,
+        shouldShow = shouldShow,
+        title = stringResource(R.string.now_playing),
+    ) {
+        PlaylistContent(
+            isVisible = shouldShow,
+            player = player,
+        )
+    }
+}
+
+@OptIn(UnstableApi::class)
+@Composable
+fun PlaylistContent(
+    isVisible: Boolean,
+    player: Player,
+) {
+    val hapticFeedback = LocalHapticFeedback.current
+    val playlistState = rememberPlaylistState(player)
+    val lazyListState = rememberLazyListState()
+    val reorderableLazyListState = rememberReorderableLazyListState(lazyListState) { from, to ->
+        playlistState.moveItem(from.index, to.index)
+        hapticFeedback.performHapticFeedback(HapticFeedbackType.SegmentFrequentTick)
+    }
+
+    LaunchedEffect(isVisible) {
+        if (isVisible && playlistState.playlist.isNotEmpty()) {
+            val currentIndex = playlistState.currentMediaItemIndex
+            if (currentIndex in playlistState.playlist.indices) {
+                lazyListState.scrollToItem(currentIndex)
+            }
+        }
+    }
+
+    if (playlistState.playlist.isEmpty()) {
+        EmptyPlaylistView()
+    } else {
+        LazyColumn(
+            modifier = Modifier.fillMaxSize(),
+            state = lazyListState,
+            contentPadding = PaddingValues(8.dp),
+            verticalArrangement = Arrangement.spacedBy(0.dp),
+        ) {
+            itemsIndexed(
+                items = playlistState.playlist,
+                key = { _, item -> item.mediaId },
+            ) { index, mediaItem ->
+                ReorderableItem(
+                    state = reorderableLazyListState,
+                    key = mediaItem.mediaId,
+                ) {
+                    val isCurrentItem = index == playlistState.currentMediaItemIndex
+                    PlaylistItemView(
+                        mediaItem = mediaItem,
+                        isFirstItem = index == 0,
+                        isLastItem = index == playlistState.playlist.lastIndex,
+                        isCurrentItem = isCurrentItem,
+                        canDelete = playlistState.playlist.size > 1,
+                        onClick = { playlistState.seekToItem(index) },
+                        onDelete = { playlistState.removeItem(index) },
+                    )
+                }
+            }
+        }
+    }
+}
+
+@kotlin.OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun ReorderableCollectionItemScope.PlaylistItemView(
+    mediaItem: MediaItem,
+    isFirstItem: Boolean = false,
+    isLastItem: Boolean = false,
+    isCurrentItem: Boolean,
+    canDelete: Boolean,
+    onClick: () -> Unit,
+    onDelete: () -> Unit,
+) {
+    val interactionSource = remember { MutableInteractionSource() }
+    val hapticFeedback = LocalHapticFeedback.current
+    NextSegmentedListItem(
+        modifier = Modifier
+            .fillMaxWidth()
+            .draggableHandle(
+                onDragStarted = {
+                    hapticFeedback.performHapticFeedback(HapticFeedbackType.GestureThresholdActivate)
+                },
+                onDragStopped = {
+                    hapticFeedback.performHapticFeedback(HapticFeedbackType.GestureEnd)
+                },
+                interactionSource = interactionSource,
+                dragGestureDetector = DragGestureDetector.LongPress,
+            ),
+        isSelected = isCurrentItem,
+        contentPadding = PaddingValues(8.dp),
+        interactionSource = interactionSource,
+        colors = ListItemDefaults.segmentedColors(
+            contentColor = if (isCurrentItem) {
+                MaterialTheme.colorScheme.primary
+            } else {
+                ListItemDefaults.segmentedColors().contentColor
+            },
+            selectedContainerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f),
+        ),
+        isFirstItem = isFirstItem,
+        isLastItem = isLastItem,
+        onClick = onClick,
+        leadingContent = {
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                app.gyrolet.mpvrx.ui.icons.Icon(
+                    imageVector = NextIcons.DragHandle,
+                    contentDescription = stringResource(R.string.reorder),
+                    tint = if (isCurrentItem) {
+                        MaterialTheme.colorScheme.primary
+                    } else {
+                        MaterialTheme.colorScheme.onSurfaceVariant
+                    },
+                )
+
+                ThumbnailView(
+                    mediaItem = mediaItem,
+                    modifier = Modifier
+                        .width(min(100.dp, LocalConfiguration.current.screenWidthDp.dp * 0.3f)),
+                )
+            }
+        },
+        content = {
+            Text(
+                text = mediaItem.mediaMetadata.title?.toString() ?: stringResource(R.string.exo_unknown),
+                maxLines = 2,
+                style = MaterialTheme.typography.titleSmall,
+                overflow = TextOverflow.Ellipsis,
+            )
+        },
+        trailingContent = {
+            if (canDelete) {
+                IconButton(onClick = onDelete) {
+                    Icon(
+                        painter = painterResource(R.drawable.ic_close),
+                        contentDescription = stringResource(R.string.remove),
+                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+            }
+        },
+    )
+}
+
+@Composable
+private fun ThumbnailView(
+    modifier: Modifier = Modifier,
+    mediaItem: MediaItem,
+) {
+    val context = LocalContext.current
+    Box(
+        modifier = modifier
+            .clip(MaterialTheme.shapes.small)
+            .background(MaterialTheme.colorScheme.surfaceVariant)
+            .aspectRatio(16f / 10f),
+    ) {
+        app.gyrolet.mpvrx.ui.icons.Icon(
+            imageVector = NextIcons.Video,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f),
+            modifier = Modifier
+                .align(Alignment.Center)
+                .fillMaxSize(0.5f),
+        )
+
+        AsyncImage(
+            model = ImageRequest.Builder(context)
+                .data(mediaItem.mediaMetadata.artworkData ?: mediaItem.mediaMetadata.artworkUri)
+                .crossfade(true)
+                .build(),
+            contentDescription = null,
+            alignment = Alignment.Center,
+            contentScale = ContentScale.Crop,
+            modifier = Modifier.fillMaxSize(),
+        )
+
+        mediaItem.mediaMetadata.durationMs?.let { durationMs ->
+            if (durationMs > 0) {
+                Text(
+                    text = Utils.formatDurationMillis(durationMs),
+                    style = MaterialTheme.typography.labelSmall.copy(fontWeight = FontWeight.Normal),
+                    color = Color.White,
+                    modifier = Modifier
+                        .align(Alignment.BottomEnd)
+                        .padding(4.dp)
+                        .clip(MaterialTheme.shapes.extraSmall)
+                        .background(Color.Black.copy(alpha = 0.6f))
+                        .padding(vertical = 1.dp, horizontal = 3.dp),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun EmptyPlaylistView() {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(32.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        app.gyrolet.mpvrx.ui.icons.Icon(
+            imageVector = NextIcons.Video,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f),
+            modifier = Modifier.fillMaxSize(0.3f),
+        )
+        Text(
+            text = stringResource(R.string.no_videos_in_queue),
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/RadioButtonRow.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/RadioButtonRow.kt
new file mode 100644
index 000000000..9e5e46493
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/RadioButtonRow.kt
@@ -0,0 +1,65 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun RadioButtonRow(
+    modifier: Modifier = Modifier,
+    isSelected: Boolean,
+    text: String,
+    testTag: String? = null,
+    onClick: () -> Unit,
+) {
+    Row(
+        modifier = modifier
+            .then(
+                if (testTag != null) {
+                    Modifier
+                        .testTag(testTag)
+                        .semantics { contentDescription = testTag }
+                } else {
+                    Modifier
+                },
+            )
+            .fillMaxWidth()
+            .clip(RoundedCornerShape(4.dp))
+            .selectable(
+                selected = isSelected,
+                onClick = onClick,
+            )
+            .padding(
+                horizontal = 4.dp,
+                vertical = 8.dp,
+            ),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        RadioButton(
+            selected = isSelected,
+            onClick = null,
+        )
+        Text(
+            text = text,
+            style = MaterialTheme.typography.bodyMedium,
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis,
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/ShutterView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/ShutterView.kt
new file mode 100644
index 000000000..0dd5f4e72
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/ShutterView.kt
@@ -0,0 +1,17 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+
+@Composable
+fun ShutterView(modifier: Modifier = Modifier) {
+    Box(
+        modifier = modifier
+            .fillMaxSize()
+            .background(Color.Black),
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/SleepTimerSelectorView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/SleepTimerSelectorView.kt
new file mode 100644
index 000000000..4f1ed3af5
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/SleepTimerSelectorView.kt
@@ -0,0 +1,140 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SleepTimerState
+
+@Composable
+fun BoxScope.SleepTimerSelectorView(
+    modifier: Modifier = Modifier,
+    shouldShow: Boolean,
+    sleepTimerState: SleepTimerState,
+    onDismiss: () -> Unit,
+) {
+    OverlayView(
+        modifier = modifier,
+        shouldShow = shouldShow,
+        title = stringResource(R.string.exo_sleep_timer),
+        testTag = "panel_sleep_timer",
+    ) {
+        SleepTimerSelectorContent(
+            sleepTimerState = sleepTimerState,
+            onDismiss = onDismiss,
+        )
+    }
+}
+
+@Composable
+fun SleepTimerSelectorContent(
+    sleepTimerState: SleepTimerState,
+    onDismiss: () -> Unit,
+) {
+    val hapticFeedback = LocalHapticFeedback.current
+    val initialMinutes = if (sleepTimerState.isActive) {
+        (sleepTimerState.remainingMillis / 60_000f).coerceAtLeast(1f)
+    } else {
+        30f
+    }
+    var sliderValue by remember { mutableFloatStateOf(initialMinutes) }
+    val displayMinutes = sliderValue.toInt()
+    val displayHours = displayMinutes / 60
+    val displayRemainderMinutes = displayMinutes % 60
+
+    Column(
+        modifier = Modifier
+            .verticalScroll(rememberScrollState())
+            .padding(bottom = 24.dp)
+            .padding(horizontal = 24.dp),
+    ) {
+        if (sleepTimerState.isActive) {
+            val remainMin = (sleepTimerState.remainingMillis / 60_000L).toInt()
+            val remainSec = ((sleepTimerState.remainingMillis % 60_000L) / 1000L).toInt()
+            Text(
+                text = "${stringResource(R.string.sleep_timer_remaining)}: ${String.format("%d:%02d", remainMin, remainSec)}",
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.fillMaxWidth(),
+                textAlign = TextAlign.Center,
+            )
+        }
+
+        Text(
+            text = when {
+                displayMinutes == 0 -> stringResource(R.string.sleep_timer_off)
+                displayHours > 0 -> String.format("%dh %02dmin", displayHours, displayRemainderMinutes)
+                else -> stringResource(R.string.sleep_timer_minutes, displayMinutes)
+            },
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(vertical = 20.dp),
+            textAlign = TextAlign.Center,
+            style = MaterialTheme.typography.titleMedium,
+        )
+
+        Slider(
+            modifier = Modifier.testTag("slider_sleep_timer"),
+            value = sliderValue,
+            onValueChange = {
+                sliderValue = it
+                hapticFeedback.performHapticFeedback(HapticFeedbackType.TextHandleMove)
+            },
+            valueRange = 0f..300f,
+        )
+
+        Spacer(modifier = Modifier.size(16.dp))
+
+        FilledTonalButton(
+            modifier = Modifier
+                .fillMaxWidth()
+                .testTag("btn_sleep_timer_confirm"),
+            onClick = {
+                if (displayMinutes > 0) {
+                    sleepTimerState.start(displayMinutes)
+                } else {
+                    sleepTimerState.cancel()
+                }
+                onDismiss()
+            },
+        ) {
+            Text(text = stringResource(R.string.generic_ok))
+        }
+
+        if (sleepTimerState.isActive) {
+            Spacer(modifier = Modifier.size(8.dp))
+            FilledTonalButton(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .testTag("btn_sleep_timer_off"),
+                onClick = {
+                    sleepTimerState.cancel()
+                    onDismiss()
+                },
+            ) {
+                Text(text = stringResource(R.string.sleep_timer_off))
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/SubtitleSelectorView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/SubtitleSelectorView.kt
new file mode 100644
index 000000000..556f591c2
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/SubtitleSelectorView.kt
@@ -0,0 +1,415 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.annotation.OptIn
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.gestures.waitForUpOrCancellation
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectableGroup
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.composed
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.dp
+import androidx.media3.common.C
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import kotlin.math.roundToLong
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ListSectionTitle
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.SubtitleStylePanel
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.getName
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SubtitleOptionsEvent
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberSubtitleOptionsState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberTracksState
+
+@OptIn(UnstableApi::class)
+@Composable
+fun BoxScope.SubtitleSelectorView(
+    modifier: Modifier = Modifier,
+    shouldShow: Boolean,
+    player: Player,
+    onSelectSubtitleClick: () -> Unit,
+    onAddOnlineSubtitleClick: (String) -> Unit,
+    preferences: PlayerPreferences,
+    onPreferencesChange: (PlayerPreferences) -> Unit,
+    onEvent: (SubtitleOptionsEvent) -> Unit = {},
+    onDismiss: () -> Unit,
+) {
+    OverlayView(
+        modifier = modifier,
+        shouldShow = shouldShow,
+        title = stringResource(R.string.select_subtitle_track),
+        testTag = "panel_subtitle_selector",
+    ) {
+        SubtitleSelectorContent(
+            player = player,
+            onSelectSubtitleClick = onSelectSubtitleClick,
+            onAddOnlineSubtitleClick = onAddOnlineSubtitleClick,
+            preferences = preferences,
+            onPreferencesChange = onPreferencesChange,
+            onEvent = onEvent,
+            onDismiss = onDismiss,
+        )
+    }
+}
+
+@OptIn(UnstableApi::class)
+@Composable
+fun SubtitleSelectorContent(
+    player: Player,
+    onSelectSubtitleClick: () -> Unit,
+    onAddOnlineSubtitleClick: (String) -> Unit,
+    preferences: PlayerPreferences,
+    onPreferencesChange: (PlayerPreferences) -> Unit,
+    onEvent: (SubtitleOptionsEvent) -> Unit = {},
+    onDismiss: () -> Unit,
+) {
+    val subtitleTracksState = rememberTracksState(player, C.TRACK_TYPE_TEXT)
+    val subtitleOptionsState = rememberSubtitleOptionsState(player, onEvent)
+    var isOnlineSubtitleDialogVisible by remember { mutableStateOf(false) }
+    var onlineSubtitleUrl by remember { mutableStateOf("") }
+
+    Column(
+        modifier = Modifier
+            .verticalScroll(rememberScrollState())
+            .padding(bottom = 24.dp)
+            .padding(horizontal = 24.dp)
+            .selectableGroup(),
+    ) {
+        subtitleTracksState.tracks.forEachIndexed { index, track ->
+            RadioButtonRow(
+                isSelected = track.isSelected,
+                text = track.mediaTrackGroup.getName(C.TRACK_TYPE_TEXT, index),
+                testTag = "item_subtitle_$index",
+                onClick = {
+                    subtitleTracksState.switchTrack(index)
+                    onDismiss()
+                },
+            )
+        }
+        RadioButtonRow(
+            isSelected = subtitleTracksState.tracks.none { it.isSelected },
+            text = stringResource(R.string.disable),
+            testTag = "item_subtitle_disable",
+            onClick = {
+                subtitleTracksState.switchTrack(-1)
+                onDismiss()
+            },
+        )
+        Spacer(modifier = Modifier.size(16.dp))
+        FilledTonalButton(
+            modifier = Modifier
+                .fillMaxWidth()
+                .testTag("btn_open_subtitle_picker"),
+            onClick = {
+                onSelectSubtitleClick()
+                onDismiss()
+            },
+        ) {
+            Text(text = stringResource(R.string.open_subtitle))
+        }
+        Spacer(modifier = Modifier.size(16.dp))
+        FilledTonalButton(
+            modifier = Modifier
+                .fillMaxWidth()
+                .testTag("btn_add_online_subtitle"),
+            onClick = {
+                isOnlineSubtitleDialogVisible = true
+            },
+        ) {
+            Text(text = stringResource(R.string.add_online_subtitle))
+        }
+        Spacer(modifier = Modifier.size(16.dp))
+        DelayInput(
+            value = subtitleOptionsState.delayMilliseconds,
+            onValueChange = { subtitleOptionsState.setDelay(it) },
+        )
+        Spacer(modifier = Modifier.size(16.dp))
+        SpeedInput(
+            value = subtitleOptionsState.speedMultiplier,
+            onValueChange = { subtitleOptionsState.setSpeed(it) },
+        )
+        Spacer(modifier = Modifier.size(16.dp))
+        ListSectionTitle(text = stringResource(id = R.string.subtitle_appearance))
+        SubtitleStylePanel(
+            preferences = preferences,
+            onPreferencesChange = onPreferencesChange,
+        )
+    }
+
+    if (isOnlineSubtitleDialogVisible) {
+        AlertDialog(
+            modifier = Modifier.testTag("dialog_online_subtitle"),
+            onDismissRequest = { isOnlineSubtitleDialogVisible = false },
+            title = {
+                Text(text = stringResource(R.string.add_online_subtitle))
+            },
+            text = {
+                OutlinedTextField(
+                    value = onlineSubtitleUrl,
+                    onValueChange = { onlineSubtitleUrl = it },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .testTag("input_online_subtitle_url"),
+                    label = {
+                        Text(text = stringResource(R.string.online_subtitle_url))
+                    },
+                    placeholder = {
+                        Text(text = "https://example.com/subtitle.srt")
+                    },
+                    singleLine = true,
+                    keyboardOptions = KeyboardOptions(
+                        keyboardType = KeyboardType.Uri,
+                    ),
+                )
+            },
+            confirmButton = {
+                TextButton(
+                    modifier = Modifier.testTag("btn_confirm_online_subtitle"),
+                    enabled = onlineSubtitleUrl.isNotBlank(),
+                    onClick = {
+                        onAddOnlineSubtitleClick(onlineSubtitleUrl.trim())
+                        onlineSubtitleUrl = ""
+                        isOnlineSubtitleDialogVisible = false
+                        onDismiss()
+                    },
+                ) {
+                    Text(text = stringResource(R.string.online_subtitle_add))
+                }
+            },
+            dismissButton = {
+                TextButton(
+                    modifier = Modifier.testTag("btn_cancel_online_subtitle"),
+                    onClick = { isOnlineSubtitleDialogVisible = false },
+                ) {
+                    Text(text = stringResource(R.string.generic_cancel))
+                }
+            },
+        )
+    }
+}
+
+@Composable
+private fun DelayInput(
+    value: Long,
+    onValueChange: (Long) -> Unit,
+) {
+    var valueString by remember {
+        mutableStateOf(if (value == 0L) "0" else "%.2f".format(value / 1000.0))
+    }
+
+    LaunchedEffect(value) {
+        val currentValue = valueString.toDoubleOrNull() ?: 0.0
+        if (currentValue == (value / 1000.0)) return@LaunchedEffect
+        valueString = if (value == 0L) "0" else "%.2f".format(value / 1000.0)
+    }
+
+    NumberChooserInput(
+        title = stringResource(R.string.delay),
+        value = valueString,
+        textFieldTestTag = "input_subtitle_delay",
+        decrementButtonTestTag = "btn_subtitle_delay_decrement",
+        incrementButtonTestTag = "btn_subtitle_delay_increment",
+        suffix = { Text(text = "sec") },
+        onValueChange = { newValue ->
+            if (newValue.isBlank()) {
+                valueString = ""
+                onValueChange(0)
+                return@NumberChooserInput
+            }
+
+            val cleanedValue = newValue.trimStart()
+
+            if (cleanedValue == "-" || cleanedValue == ".") {
+                valueString = cleanedValue
+                return@NumberChooserInput
+            }
+
+            val decimalPattern = "^-?\\d*\\.?\\d{0,2}$".toRegex()
+            if (!cleanedValue.matches(decimalPattern)) {
+                return@NumberChooserInput
+            }
+
+            valueString = cleanedValue
+
+            runCatching {
+                val doubleValue = cleanedValue.toDoubleOrNull() ?: 0.0
+                val milliseconds = (doubleValue * 1000).roundToLong()
+                onValueChange(milliseconds)
+            }
+        },
+        onIncrement = { onValueChange(value + 100) },
+        onDecrement = { onValueChange(value - 100) },
+    )
+}
+
+@Composable
+private fun SpeedInput(
+    value: Float,
+    onValueChange: (Float) -> Unit,
+) {
+    var valueString by remember {
+        mutableStateOf(if (value == 1f) "1" else "%.2f".format(value))
+    }
+
+    LaunchedEffect(value) {
+        val currentValue = valueString.toFloatOrNull() ?: 0.0
+        if (currentValue == value) return@LaunchedEffect
+        valueString = if (value == 1f) "1" else "%.2f".format(value)
+    }
+
+    NumberChooserInput(
+        title = stringResource(R.string.exo_speed),
+        value = valueString,
+        textFieldTestTag = "input_subtitle_speed",
+        decrementButtonTestTag = "btn_subtitle_speed_decrement",
+        incrementButtonTestTag = "btn_subtitle_speed_increment",
+        suffix = { Text(text = "x") },
+        onValueChange = { newValue ->
+            if (newValue.isBlank()) {
+                valueString = ""
+                onValueChange(1f)
+                return@NumberChooserInput
+            }
+
+            val cleanedValue = newValue.trimStart()
+
+            if (cleanedValue == ".") {
+                valueString = cleanedValue
+                return@NumberChooserInput
+            }
+
+            val decimalPattern = "^\\d*\\.?\\d{0,2}$".toRegex()
+            if (!cleanedValue.matches(decimalPattern)) {
+                return@NumberChooserInput
+            }
+
+            valueString = cleanedValue
+
+            runCatching {
+                val floatValue = cleanedValue.toFloatOrNull() ?: 1f
+                onValueChange(floatValue)
+            }
+        },
+        onIncrement = { onValueChange(value + 0.1f) },
+        onDecrement = { onValueChange(value - 0.1f) },
+    )
+}
+
+@Composable
+private fun NumberChooserInput(
+    modifier: Modifier = Modifier,
+    title: String,
+    value: String,
+    textFieldTestTag: String? = null,
+    decrementButtonTestTag: String? = null,
+    incrementButtonTestTag: String? = null,
+    onValueChange: (String) -> Unit,
+    onIncrement: () -> Unit = {},
+    onDecrement: () -> Unit = {},
+    suffix: @Composable (() -> Unit)? = null,
+) {
+    Row(
+        modifier = modifier,
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        FilledTonalIconButton(
+            onClick = { },
+            modifier = Modifier
+                .then(decrementButtonTestTag?.let(Modifier::testTag) ?: Modifier)
+                .repeatingClickable(onClick = onDecrement),
+        ) {
+            Icon(
+                painter = painterResource(R.drawable.ic_remove),
+                contentDescription = null,
+            )
+        }
+        OutlinedTextField(
+            label = { Text(text = title) },
+            value = value,
+            onValueChange = onValueChange,
+            modifier = Modifier
+                .weight(1f)
+                .then(textFieldTestTag?.let(Modifier::testTag) ?: Modifier),
+            suffix = suffix,
+            singleLine = true,
+            keyboardOptions = KeyboardOptions(
+                keyboardType = KeyboardType.Decimal,
+            ),
+        )
+        FilledTonalIconButton(
+            onClick = { },
+            modifier = Modifier
+                .then(incrementButtonTestTag?.let(Modifier::testTag) ?: Modifier)
+                .repeatingClickable(onClick = onIncrement),
+        ) {
+            Icon(
+                painter = painterResource(R.drawable.ic_add),
+                contentDescription = null,
+            )
+        }
+    }
+}
+
+private fun Modifier.repeatingClickable(
+    isEnabled: Boolean = true,
+    maxDelayMillis: Long = 200,
+    minDelayMillis: Long = 5,
+    delayDecayFactor: Float = .20f,
+    onClick: () -> Unit,
+): Modifier = composed {
+    val updatedOnClick by rememberUpdatedState(onClick)
+
+    this.pointerInput(isEnabled) {
+        coroutineScope {
+            awaitEachGesture {
+                val down = awaitFirstDown(requireUnconsumed = false)
+                val heldButtonJob = launch {
+                    var currentDelayMillis = maxDelayMillis
+                    while (isEnabled && down.pressed) {
+                        updatedOnClick()
+                        delay(currentDelayMillis)
+                        val nextMillis = currentDelayMillis - (currentDelayMillis * delayDecayFactor)
+                        currentDelayMillis = nextMillis.toLong().coerceAtLeast(minDelayMillis)
+                    }
+                }
+                waitForUpOrCancellation()
+                heldButtonJob.cancel()
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/SubtitleView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/SubtitleView.kt
new file mode 100644
index 000000000..4cf51109c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/SubtitleView.kt
@@ -0,0 +1,203 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import android.graphics.Color
+import android.graphics.Typeface
+import android.util.TypedValue
+import android.view.accessibility.CaptioningManager
+import androidx.annotation.OptIn
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.content.ContextCompat.getSystemService
+import androidx.media3.common.C
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.ui.CaptionStyleCompat
+import androidx.media3.ui.SubtitleView
+import io.github.peerless2012.ass.media.AssHandler
+import io.github.peerless2012.ass.media.kt.withAssSupport
+import io.github.peerless2012.ass.media.widget.AssSubtitleView as AssMediaSubtitleView
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.ExternalSubtitleFontSource
+import app.gyrolet.mpvrx.exoplayer.core.model.Font
+import app.gyrolet.mpvrx.exoplayer.core.model.SubtitleColor
+import app.gyrolet.mpvrx.exoplayer.core.model.SubtitleEdgeStyle
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.toTypeface
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberCuesState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.rememberTracksState
+import app.gyrolet.mpvrx.exoplayer.feature.player.subtitle.AssHandlerRegistry
+import app.gyrolet.mpvrx.exoplayer.feature.player.subtitle.SubtitleFontPolicy
+import app.gyrolet.mpvrx.exoplayer.feature.player.subtitle.decideSubtitleFontPolicy
+
+@OptIn(UnstableApi::class)
+@Composable
+fun SubtitleView(
+    modifier: Modifier = Modifier,
+    player: Player,
+    isInPictureInPictureMode: Boolean,
+    configuration: SubtitleConfiguration,
+) {
+    val cuesState = rememberCuesState(player)
+    val assHandler by AssHandlerRegistry.handler.collectAsState()
+    val textTracksState = rememberTracksState(player = player, trackType = C.TRACK_TYPE_TEXT)
+    val isAssSubtitleSelected = textTracksState.tracks.any { track ->
+        track.isSelected &&
+            (0 until track.mediaTrackGroup.length).any { index ->
+                val format = track.mediaTrackGroup.getFormat(index)
+                format.sampleMimeType == MimeTypes.TEXT_SSA || format.codecs == MimeTypes.TEXT_SSA
+            }
+    }
+
+    val subtitleFontPolicy = decideSubtitleFontPolicy(
+        isAssSubtitleSelected = isAssSubtitleSelected,
+        shouldUseSystemCaptionStyle = configuration.shouldUseSystemCaptionStyle,
+        hasExternalFont = configuration.externalSubtitleFontSource != null,
+    )
+
+    AndroidView(
+        modifier = modifier.fillMaxSize(),
+        factory = { context ->
+            SubtitleView(context).apply {
+                applySubtitleStyle(
+                    configuration = configuration,
+                    subtitleFontPolicy = subtitleFontPolicy,
+                )
+                setApplyEmbeddedStyles(configuration.shouldApplyEmbeddedStyles)
+                applySubtitlePosition(
+                    configuration = configuration,
+                    subtitleFontPolicy = subtitleFontPolicy,
+                )
+            }
+        },
+        update = { subtitleView ->
+            if (isAssSubtitleSelected) {
+                assHandler?.let(subtitleView::syncAssSupport)
+                    ?: subtitleView.clearAssSupport()
+                subtitleView.setCues(emptyList())
+            } else {
+                subtitleView.clearAssSupport()
+                subtitleView.setCues(cuesState.cues)
+            }
+
+            subtitleView.applySubtitleStyle(
+                configuration = configuration,
+                subtitleFontPolicy = subtitleFontPolicy,
+            )
+            subtitleView.setApplyEmbeddedStyles(configuration.shouldApplyEmbeddedStyles)
+            subtitleView.applySubtitlePosition(
+                configuration = configuration,
+                subtitleFontPolicy = subtitleFontPolicy,
+            )
+
+            if (isInPictureInPictureMode) {
+                subtitleView.setFractionalTextSize(SubtitleView.DEFAULT_TEXT_SIZE_FRACTION)
+            } else {
+                subtitleView.setFixedTextSize(TypedValue.COMPLEX_UNIT_SP, configuration.textSize.toFloat())
+            }
+        },
+    )
+}
+
+@Stable
+data class SubtitleConfiguration(
+    val shouldUseSystemCaptionStyle: Boolean,
+    val shouldShowBackground: Boolean,
+    val font: Font,
+    val textSize: Int,
+    val shouldUseBoldText: Boolean,
+    val color: SubtitleColor,
+    val edgeStyle: SubtitleEdgeStyle,
+    val bottomPaddingFraction: Float,
+    val shouldApplyEmbeddedStyles: Boolean,
+    val externalSubtitleFontSource: ExternalSubtitleFontSource?,
+)
+
+@OptIn(UnstableApi::class)
+private fun SubtitleView.syncAssSupport(handler: AssHandler) {
+    val assSupportView = findAssSupportView()
+    val currentHandler = assSupportView?.tag as? AssHandler
+    if (currentHandler === handler) return
+
+    assSupportView?.let(::removeView)
+    this.withAssSupport(handler)
+    findAssSupportView()?.tag = handler
+}
+
+@OptIn(UnstableApi::class)
+private fun SubtitleView.clearAssSupport() {
+    findAssSupportView()?.let(::removeView)
+}
+
+@OptIn(UnstableApi::class)
+private fun SubtitleView.applySubtitleStyle(
+    configuration: SubtitleConfiguration,
+    subtitleFontPolicy: SubtitleFontPolicy,
+) {
+    val context = context
+    val captioningManager = getSystemService(context, CaptioningManager::class.java) ?: return
+    when (subtitleFontPolicy) {
+        SubtitleFontPolicy.Ass,
+        SubtitleFontPolicy.SystemCaptionStyle,
+        -> {
+            val systemCaptionStyle = CaptionStyleCompat.createFromCaptionStyle(captioningManager.userStyle)
+            setStyle(systemCaptionStyle)
+        }
+
+        SubtitleFontPolicy.ExternalOrFallback -> {
+            val baseTypeface = runCatching {
+                configuration.externalSubtitleFontSource
+                    ?.absolutePath
+                    ?.let(Typeface::createFromFile)
+            }.getOrNull() ?: configuration.font.toTypeface()
+            val userStyle = CaptionStyleCompat(
+                configuration.color.toArgb(),
+                Color.BLACK.takeIf { configuration.shouldShowBackground } ?: Color.TRANSPARENT,
+                Color.TRANSPARENT,
+                configuration.edgeStyle.toCaptionEdgeType(),
+                Color.BLACK,
+                Typeface.create(
+                    baseTypeface,
+                    Typeface.BOLD.takeIf { configuration.shouldUseBoldText } ?: Typeface.NORMAL,
+                ),
+            )
+            setStyle(userStyle)
+            setFixedTextSize(TypedValue.COMPLEX_UNIT_SP, configuration.textSize.toFloat())
+        }
+    }
+}
+
+@OptIn(UnstableApi::class)
+private fun SubtitleView.applySubtitlePosition(
+    configuration: SubtitleConfiguration,
+    subtitleFontPolicy: SubtitleFontPolicy,
+) {
+    val bottomPaddingFraction = when (subtitleFontPolicy) {
+        SubtitleFontPolicy.ExternalOrFallback -> configuration.bottomPaddingFraction
+        SubtitleFontPolicy.Ass,
+        SubtitleFontPolicy.SystemCaptionStyle,
+        -> SubtitleView.DEFAULT_BOTTOM_PADDING_FRACTION
+    }
+    setBottomPaddingFraction(bottomPaddingFraction)
+}
+
+private fun SubtitleColor.toArgb(): Int = when (this) {
+    SubtitleColor.WHITE -> Color.WHITE
+    SubtitleColor.YELLOW -> Color.YELLOW
+    SubtitleColor.CYAN -> Color.CYAN
+    SubtitleColor.GREEN -> Color.GREEN
+}
+
+private fun SubtitleEdgeStyle.toCaptionEdgeType(): Int = when (this) {
+    SubtitleEdgeStyle.NONE -> CaptionStyleCompat.EDGE_TYPE_NONE
+    SubtitleEdgeStyle.OUTLINE -> CaptionStyleCompat.EDGE_TYPE_OUTLINE
+    SubtitleEdgeStyle.DROP_SHADOW -> CaptionStyleCompat.EDGE_TYPE_DROP_SHADOW
+}
+
+@OptIn(UnstableApi::class)
+private fun SubtitleView.findAssSupportView(): AssMediaSubtitleView? = (0 until childCount).firstNotNullOfOrNull { index ->
+    getChildAt(index) as? AssMediaSubtitleView
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/VerticalProgressView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/VerticalProgressView.kt
new file mode 100644
index 000000000..ad3f2fb7c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/VerticalProgressView.kt
@@ -0,0 +1,90 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.annotation.IntRange
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.text.BasicText
+import androidx.compose.foundation.text.TextAutoSize
+import app.gyrolet.mpvrx.ui.icons.AppIcon
+import app.gyrolet.mpvrx.ui.icons.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+private const val NORMAL_MAX_PERCENTAGE = 100
+
+@Composable
+fun VerticalProgressView(
+    modifier: Modifier = Modifier,
+    width: Dp = 32.dp,
+    icon: AppIcon,
+    @IntRange(from = 0, to = 200) value: Int,
+    maxValue: Int = NORMAL_MAX_PERCENTAGE,
+    boostColor: Color = Color(0xFFFC6E6E),
+) {
+    val normalizedValue = value.coerceIn(0, maxValue)
+    val fillFraction = normalizedValue.toFloat() / maxValue.toFloat()
+    val isBoostActive = maxValue > NORMAL_MAX_PERCENTAGE && value > NORMAL_MAX_PERCENTAGE
+
+    Column(
+        modifier = modifier
+            .heightIn(max = 250.dp)
+            .clip(CircleShape)
+            .background(MaterialTheme.colorScheme.background)
+            .padding(8.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+        Box(
+            modifier = Modifier.size(width),
+            contentAlignment = Alignment.Center,
+        ) {
+            BasicText(
+                text = normalizedValue.toString(),
+                style = MaterialTheme.typography.labelLarge.copy(
+                    color = MaterialTheme.colorScheme.onBackground,
+                ),
+                autoSize = TextAutoSize.StepBased(maxFontSize = MaterialTheme.typography.labelLarge.fontSize),
+            )
+        }
+        Box(
+            modifier = Modifier
+                .weight(1f)
+                .width(width)
+                .clip(MaterialTheme.shapes.medium)
+                .background(MaterialTheme.colorScheme.surfaceVariant),
+            contentAlignment = Alignment.BottomCenter,
+        ) {
+            Box(
+                modifier = Modifier
+                    .width(width)
+                    .fillMaxHeight(fillFraction)
+                    .background(if (isBoostActive) boostColor else MaterialTheme.colorScheme.primary),
+            )
+        }
+        Box(
+            modifier = Modifier.size(width),
+            contentAlignment = Alignment.Center,
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.onBackground,
+            )
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/VideoContentScaleSelectorView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/VideoContentScaleSelectorView.kt
new file mode 100644
index 000000000..6653a09a9
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/VideoContentScaleSelectorView.kt
@@ -0,0 +1,84 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui
+
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectableGroup
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.exoplayer.core.model.VideoContentScale
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.nameRes
+
+@Composable
+fun BoxScope.VideoContentScaleSelectorView(
+    modifier: Modifier = Modifier,
+    shouldShow: Boolean,
+    videoContentScale: VideoContentScale,
+    onVideoContentScaleChanged: (VideoContentScale) -> Unit,
+    onShowVideoFilters: (() -> Unit)?,
+    onDismiss: () -> Unit,
+) {
+    OverlayView(
+        modifier = modifier,
+        shouldShow = shouldShow,
+        title = stringResource(R.string.video_zoom),
+    ) {
+        VideoContentScaleSelectorContent(
+            videoContentScale = videoContentScale,
+            onVideoContentScaleChanged = onVideoContentScaleChanged,
+            onShowVideoFilters = onShowVideoFilters,
+            onDismiss = onDismiss,
+        )
+    }
+}
+
+@Composable
+fun VideoContentScaleSelectorContent(
+    videoContentScale: VideoContentScale,
+    onVideoContentScaleChanged: (VideoContentScale) -> Unit,
+    onShowVideoFilters: (() -> Unit)?,
+    onDismiss: () -> Unit,
+) {
+    Column(
+        modifier = Modifier
+            .verticalScroll(rememberScrollState())
+            .padding(bottom = 24.dp)
+            .padding(horizontal = 24.dp),
+    ) {
+        if (onShowVideoFilters != null) {
+            FilledTonalButton(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .testTag("btn_open_video_filters"),
+                onClick = onShowVideoFilters,
+            ) {
+                Text(text = stringResource(R.string.video_filters))
+            }
+            Spacer(modifier = Modifier.size(16.dp))
+        }
+
+        Column(modifier = Modifier.selectableGroup()) {
+            VideoContentScale.entries.forEach { contentScale ->
+                RadioButtonRow(
+                    isSelected = contentScale == videoContentScale,
+                    text = stringResource(contentScale.nameRes()),
+                    onClick = {
+                        onVideoContentScaleChanged(contentScale)
+                        onDismiss()
+                    },
+                )
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsBottomModernView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsBottomModernView.kt
new file mode 100644
index 000000000..0dc81802f
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsBottomModernView.kt
@@ -0,0 +1,233 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui.controls
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.displayCutout
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.foundation.layout.union
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Slider
+import androidx.compose.material3.SliderDefaults
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.dp
+import kotlin.time.Duration.Companion.milliseconds
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.feature.player.LocalControlsVisibilityState
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.formatted
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.noRippleClickable
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.MediaPresentationState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.durationFormatted
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@Composable
+fun ControlsBottomModernView(
+    modifier: Modifier = Modifier,
+    mediaPresentationState: MediaPresentationState,
+    pendingSeekPosition: Long?,
+    isPlaying: Boolean,
+    hasPrevious: Boolean,
+    hasNext: Boolean,
+    onPlayPauseClick: () -> Unit,
+    onPreviousClick: () -> Unit,
+    onNextClick: () -> Unit,
+    onRotateClick: () -> Unit,
+    onPlaylistClick: () -> Unit,
+    onPlaybackSpeedClick: () -> Unit,
+    onSeek: (Long) -> Unit,
+    onSeekEnd: () -> Unit,
+) {
+    val systemBarsPadding = WindowInsets.systemBars.union(WindowInsets.displayCutout).asPaddingValues()
+    val controlsVisibilityState = LocalControlsVisibilityState.current
+    val displayedPosition = pendingSeekPosition ?: mediaPresentationState.position
+    val displayedPendingPosition = (mediaPresentationState.duration - displayedPosition).coerceAtLeast(0L)
+    Column(
+        modifier = modifier
+            .padding(systemBarsPadding)
+            .padding(horizontal = 8.dp, vertical = 8.dp),
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+        ModernSeekbar(
+            position = displayedPosition.toFloat(),
+            duration = mediaPresentationState.duration.toFloat(),
+            onSeek = {
+                controlsVisibilityState?.showControls()
+                onSeek(it.toLong())
+            },
+            onSeekFinished = { onSeekEnd() },
+        )
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            IconButton(
+                modifier = Modifier.testTag("btn_play_pause_modern"),
+                onClick = onPlayPauseClick,
+            ) {
+                Icon(
+                    modifier = Modifier.size(28.dp),
+                    imageVector = if (isPlaying) NextIcons.Pause else NextIcons.Play,
+                    contentDescription = stringResource(R.string.player_controls_play_pause),
+                    tint = Color.White,
+                )
+            }
+            var shouldShowPendingPosition by rememberSaveable { mutableStateOf(false) }
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier
+                    .padding(horizontal = 4.dp)
+                    .noRippleClickable {
+                        shouldShowPendingPosition = !shouldShowPendingPosition
+                    },
+            ) {
+                Text(
+                    text = when (shouldShowPendingPosition) {
+                        true -> "-${displayedPendingPosition.milliseconds.formatted()}"
+                        false -> displayedPosition.milliseconds.formatted()
+                    },
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = Color.White,
+                )
+                Text(
+                    text = " / ",
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = Color.White,
+                )
+                Text(
+                    text = mediaPresentationState.durationFormatted,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = Color.White,
+                )
+            }
+            IconButton(
+                modifier = Modifier.testTag("btn_previous_modern"),
+                onClick = onPreviousClick,
+                enabled = hasPrevious,
+            ) {
+                Icon(
+                    modifier = Modifier.size(24.dp),
+                    imageVector = NextIcons.SkipPrevious,
+                    contentDescription = stringResource(R.string.player_controls_previous),
+                    tint = if (hasPrevious) Color.White else Color.White.copy(alpha = 0.4f),
+                )
+            }
+            IconButton(
+                modifier = Modifier.testTag("btn_next_modern"),
+                onClick = onNextClick,
+                enabled = hasNext,
+            ) {
+                Icon(
+                    modifier = Modifier.size(24.dp),
+                    imageVector = NextIcons.SkipNext,
+                    contentDescription = stringResource(R.string.player_controls_next),
+                    tint = if (hasNext) Color.White else Color.White.copy(alpha = 0.4f),
+                )
+            }
+            Spacer(modifier = Modifier.weight(1f))
+            IconButton(
+                modifier = Modifier.testTag("btn_rotate_modern"),
+                onClick = onRotateClick,
+            ) {
+                Icon(
+                    modifier = Modifier.size(24.dp),
+                    imageVector = NextIcons.Rotation,
+                    contentDescription = stringResource(R.string.screen_rotation),
+                    tint = Color.White,
+                )
+            }
+            IconButton(
+                modifier = Modifier.testTag("btn_playlist_modern"),
+                onClick = onPlaylistClick,
+            ) {
+                Icon(
+                    modifier = Modifier.size(24.dp),
+                    imageVector = NextIcons.PlaylistPlay,
+                    contentDescription = stringResource(R.string.now_playing),
+                    tint = Color.White,
+                )
+            }
+            IconButton(
+                modifier = Modifier.testTag("btn_speed_modern"),
+                onClick = onPlaybackSpeedClick,
+            ) {
+                Icon(
+                    modifier = Modifier.size(24.dp),
+                    imageVector = NextIcons.Speed,
+                    contentDescription = stringResource(R.string.select_playback_speed),
+                    tint = Color.White,
+                )
+            }
+        }
+    }
+}
+
+@kotlin.OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun ModernSeekbar(
+    modifier: Modifier = Modifier,
+    position: Float,
+    duration: Float,
+    onSeek: (Float) -> Unit,
+    onSeekFinished: () -> Unit,
+) {
+    val accentColor = MaterialTheme.colorScheme.primary
+    CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Ltr) {
+        Slider(
+            modifier = modifier.fillMaxWidth(),
+            value = position.coerceIn(0f, duration.coerceAtLeast(0f)),
+            valueRange = 0f..duration.coerceAtLeast(0f),
+            onValueChange = onSeek,
+            onValueChangeFinished = onSeekFinished,
+            thumb = {
+                Box(
+                    modifier = Modifier
+                        .size(14.dp)
+                        .border(2.dp, Color.White, CircleShape)
+                        .padding(2.dp)
+                        .clip(CircleShape)
+                        .background(accentColor),
+                )
+            },
+            track = { sliderState ->
+                SliderDefaults.Track(
+                    sliderState = sliderState,
+                    modifier = Modifier.height(4.dp),
+                    colors = SliderDefaults.colors(
+                        activeTrackColor = accentColor,
+                        inactiveTrackColor = Color.White.copy(alpha = 0.3f),
+                    ),
+                    thumbTrackGapSize = 0.dp,
+                    drawStopIndicator = null,
+                )
+            },
+        )
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsBottomView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsBottomView.kt
new file mode 100644
index 000000000..2c8f37662
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsBottomView.kt
@@ -0,0 +1,410 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui.controls
+
+import androidx.annotation.OptIn
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.displayCutout
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.foundation.layout.union
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.geometry.RoundRect
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.dp
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import kotlin.time.Duration.Companion.milliseconds
+import app.gyrolet.mpvrx.exoplayer.core.model.ControlButtonsPosition
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControl
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControlZone
+import app.gyrolet.mpvrx.exoplayer.core.model.VideoContentScale
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.copy
+import app.gyrolet.mpvrx.exoplayer.feature.player.AnimatedPlayerControlPlacement
+import app.gyrolet.mpvrx.exoplayer.feature.player.LocalControlsVisibilityState
+import app.gyrolet.mpvrx.exoplayer.feature.player.buttons.PlayerButton
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.formatted
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.noRippleClickable
+import app.gyrolet.mpvrx.exoplayer.feature.player.playerControlDragSource
+import app.gyrolet.mpvrx.exoplayer.feature.player.playerControlZoneTarget
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.MediaPresentationState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SleepTimerState
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.durationFormatted
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@OptIn(UnstableApi::class)
+@Composable
+fun ControlsBottomView(
+    modifier: Modifier = Modifier,
+    player: Player,
+    mediaPresentationState: MediaPresentationState,
+    bottomLeftControls: List<PlayerControl>,
+    controlButtonsPosition: ControlButtonsPosition,
+    videoContentScale: VideoContentScale,
+    isPipSupported: Boolean,
+    pendingSeekPosition: Long?,
+    itemBounds: MutableMap<PlayerControl, Rect>,
+    zoneBounds: MutableMap<PlayerControlZone, Rect>,
+    onPlaylistClick: () -> Unit,
+    onPlaybackSpeedClick: () -> Unit,
+    onAudioClick: () -> Unit,
+    onSubtitleClick: () -> Unit,
+    onVideoContentScaleClick: () -> Unit,
+    onVideoContentScaleLongClick: () -> Unit,
+    onDecoderClick: () -> Unit,
+    onAmbienceModeClick: () -> Unit,
+    isAmbienceModeEnabled: Boolean,
+    onVideoFiltersClick: () -> Unit,
+    onLockControlsClick: () -> Unit,
+    onPictureInPictureClick: () -> Unit,
+    onRotateClick: () -> Unit,
+    onPlayInBackgroundClick: () -> Unit,
+    isTakingScreenshot: Boolean,
+    onScreenshotClick: () -> Unit,
+    onCustomizeControlsClick: () -> Unit,
+    onLoopClick: (() -> Unit)? = null,
+    onShuffleClick: (() -> Unit)? = null,
+    onSleepTimerClick: (() -> Unit)? = null,
+    sleepTimerState: SleepTimerState? = null,
+    isCustomizingControls: Boolean,
+    shouldHideLabels: Boolean,
+    draggingControl: PlayerControl? = null,
+    onControlDropDragged: (PlayerControl, Offset) -> Unit = { _, _ -> },
+    onControlDragStarted: (PlayerControl) -> Unit = {},
+    onControlDragMoved: (PlayerControl, Offset) -> Unit = { _, _ -> },
+    onControlDragCancelled: (PlayerControl) -> Unit = {},
+    visiblePlayerControls: Set<PlayerControl>,
+    onSeek: (Long) -> Unit,
+    onSeekEnd: () -> Unit,
+) {
+    val systemBarsPadding = WindowInsets.systemBars.union(WindowInsets.displayCutout).asPaddingValues()
+    val controlsVisibilityState = LocalControlsVisibilityState.current
+    val displayedPosition = pendingSeekPosition ?: mediaPresentationState.position
+    val displayedPendingPosition = (mediaPresentationState.duration - displayedPosition).coerceAtLeast(0L)
+
+    Column(
+        modifier = modifier
+            .padding(systemBarsPadding.copy(top = 0.dp))
+            .padding(horizontal = 8.dp)
+            .padding(top = 16.dp, bottom = 24.dp),
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+        Row(
+            modifier = Modifier.padding(horizontal = 8.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            var shouldShowPendingPosition by rememberSaveable { mutableStateOf(false) }
+
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.noRippleClickable {
+                    shouldShowPendingPosition = !shouldShowPendingPosition
+                },
+            ) {
+                Text(
+                    text = when (shouldShowPendingPosition) {
+                        true -> "-${displayedPendingPosition.milliseconds.formatted()}"
+                        false -> displayedPosition.milliseconds.formatted()
+                    },
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = Color.White,
+                )
+                Text(
+                    text = " / ",
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = Color.White,
+                )
+                Text(
+                    text = mediaPresentationState.durationFormatted,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = Color.White,
+                )
+            }
+
+            Spacer(modifier = Modifier.weight(1f))
+            PlayerButton(
+                buttonSize = 30.dp,
+                onClick = onRotateClick,
+                shouldShowSelectionBadge = false,
+                shouldDimWhenUnselected = false,
+                shouldShowCustomizeFrame = false,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Rotation,
+                    contentDescription = "btn_rotate",
+                    modifier = Modifier.size(12.dp),
+                    tint = Color.White,
+                )
+            }
+        }
+        PlayerSeekbar(
+            position = displayedPosition.toFloat(),
+            duration = mediaPresentationState.duration.toFloat(),
+            onSeek = {
+                controlsVisibilityState?.showControls()
+                onSeek(it.toLong())
+            },
+            onSeekFinished = { onSeekEnd() },
+        )
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .then(
+                    when (isCustomizingControls) {
+                        true ->
+                            Modifier
+                                .playerControlZoneTarget(
+                                    zone = PlayerControlZone.BOTTOM_LEFT,
+                                    zoneBounds = zoneBounds,
+                                )
+                                .heightIn(min = 72.dp)
+                        false -> Modifier
+                    },
+                )
+                .horizontalScroll(rememberScrollState()),
+            verticalAlignment = when (isCustomizingControls) {
+                true -> Alignment.Top
+                false -> Alignment.CenterVertically
+            },
+            horizontalArrangement = when (controlButtonsPosition) {
+                ControlButtonsPosition.LEFT -> Arrangement.spacedBy(8.dp, Alignment.Start)
+                ControlButtonsPosition.RIGHT -> Arrangement.spacedBy(8.dp, Alignment.End)
+            },
+        ) {
+            bottomLeftControls.forEach { control ->
+                if (!isCustomizingControls && control !in visiblePlayerControls) return@forEach
+                key(control) {
+                    AnimatedPlayerControlPlacement(
+                        control = control,
+                        itemBounds = itemBounds,
+                        isTracking = isCustomizingControls,
+                    ) {
+                        PlayerCustomizableControlButton(
+                            modifier = Modifier.playerControlDragSource(
+                                control = control,
+                                enabled = isCustomizingControls,
+                                onDropDragged = onControlDropDragged,
+                                onDragStarted = onControlDragStarted,
+                                onDragMoved = onControlDragMoved,
+                                onDragCancelled = onControlDragCancelled,
+                            ),
+                            control = control,
+                            isBeingDragged = draggingControl == control,
+                            player = player,
+                            videoContentScale = videoContentScale,
+                            isPipSupported = isPipSupported,
+                            isCustomizingControls = isCustomizingControls,
+                            shouldHideLabel = shouldHideLabels,
+                            visiblePlayerControls = visiblePlayerControls,
+                            onPlaylistClick = onPlaylistClick,
+                            onPlaybackSpeedClick = onPlaybackSpeedClick,
+                            onAudioClick = onAudioClick,
+                            onSubtitleClick = onSubtitleClick,
+                            onLockControlsClick = onLockControlsClick,
+                            onVideoContentScaleClick = onVideoContentScaleClick,
+                            onVideoContentScaleLongClick = onVideoContentScaleLongClick,
+                            onDecoderClick = onDecoderClick,
+                            onAmbienceModeClick = onAmbienceModeClick,
+                            isAmbienceModeEnabled = isAmbienceModeEnabled,
+                            onVideoFiltersClick = onVideoFiltersClick,
+                            onPictureInPictureClick = onPictureInPictureClick,
+                            onRotateClick = onRotateClick,
+                            isTakingScreenshot = isTakingScreenshot,
+                            onScreenshotClick = onScreenshotClick,
+                            onPlayInBackgroundClick = onPlayInBackgroundClick,
+                            onLoopClick = onLoopClick,
+                            onShuffleClick = onShuffleClick,
+                            onSleepTimerClick = onSleepTimerClick,
+                            sleepTimerState = sleepTimerState,
+                        )
+                    }
+                }
+            }
+            if (!isCustomizingControls) {
+                PlayerButton(
+                    onClick = onCustomizeControlsClick,
+                    isSelected = false,
+                    label = stringResource(R.string.customize_player_controls).takeUnless { shouldHideLabels },
+                    shouldShowSelectionBadge = false,
+                    shouldDimWhenUnselected = false,
+                    shouldShowCustomizeFrame = false,
+                ) {
+                    Icon(
+                        imageVector = NextIcons.Edit,
+                        contentDescription = "btn_customize_controls",
+                    )
+                }
+            }
+        }
+    }
+}
+
+@kotlin.OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun PlayerSeekbar(
+    modifier: Modifier = Modifier,
+    position: Float,
+    duration: Float,
+    onSeek: (Float) -> Unit,
+    onSeekFinished: () -> Unit,
+) {
+    CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Ltr) {
+        MaterialYouSlider(
+            modifier = modifier.fillMaxWidth(),
+            value = position,
+            valueRange = 0f..duration,
+            onValueChange = onSeek,
+            onValueChangeFinished = onSeekFinished,
+        )
+    }
+}
+
+@kotlin.OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun MaterialYouSlider(
+    modifier: Modifier = Modifier,
+    value: Float,
+    valueRange: ClosedFloatingPointRange<Float>,
+    onValueChange: (Float) -> Unit,
+    onValueChangeFinished: () -> Unit,
+) {
+    val primaryColor = MaterialTheme.colorScheme.primary
+    val interactionSource = remember { MutableInteractionSource() }
+    val trackHeight = 8.dp
+    val thumbWidth = 4.dp
+    val trackThumbGapWidth = 12.dp
+
+    Slider(
+        value = value,
+        valueRange = valueRange,
+        onValueChange = onValueChange,
+        onValueChangeFinished = onValueChangeFinished,
+        interactionSource = interactionSource,
+        modifier = modifier.height(24.dp).semantics { contentDescription = "slider_seek" },
+        track = { sliderState ->
+            val disabledAlpha = 0.4f
+
+            Canvas(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(trackHeight),
+            ) {
+                val min = sliderState.valueRange.start
+                val max = sliderState.valueRange.endInclusive
+                val range = (max - min).takeIf { it > 0f } ?: 1f
+                val playedFraction = ((sliderState.value - min) / range).coerceIn(0f, 1f)
+                val playedPixels = size.width * playedFraction
+
+                val endCornerRadius = size.height / 2f
+                val insideCornerRadius = 2.dp.toPx()
+                val gapHalf = trackThumbGapWidth.toPx() / 2f
+                val leftEnd = (playedPixels - gapHalf).coerceIn(0f, size.width)
+                val rightStart = (playedPixels + gapHalf).coerceIn(0f, size.width)
+
+                if (leftEnd > 0f) {
+                    drawRoundedRect(
+                        offset = Offset(0f, 0f),
+                        size = Size(leftEnd, size.height),
+                        color = primaryColor.copy(alpha = disabledAlpha),
+                        startCornerRadius = endCornerRadius,
+                        endCornerRadius = insideCornerRadius,
+                    )
+                }
+
+                if (rightStart < size.width) {
+                    drawRoundedRect(
+                        offset = Offset(rightStart, 0f),
+                        size = Size(size.width - rightStart, size.height),
+                        color = primaryColor.copy(alpha = disabledAlpha),
+                        startCornerRadius = insideCornerRadius,
+                        endCornerRadius = endCornerRadius,
+                    )
+                }
+
+                if (leftEnd > 0f) {
+                    drawRoundedRect(
+                        offset = Offset(0f, 0f),
+                        size = Size(leftEnd, size.height),
+                        color = primaryColor,
+                        startCornerRadius = endCornerRadius,
+                        endCornerRadius = insideCornerRadius,
+                    )
+                }
+            }
+        },
+        thumb = {
+            Box(
+                modifier = Modifier
+                    .width(thumbWidth)
+                    .height(20.dp)
+                    .background(primaryColor, CircleShape),
+            )
+        },
+    )
+}
+
+private fun DrawScope.drawRoundedRect(
+    offset: Offset,
+    size: Size,
+    color: Color,
+    startCornerRadius: Float,
+    endCornerRadius: Float,
+) {
+    val startCorner = CornerRadius(startCornerRadius, startCornerRadius)
+    val endCorner = CornerRadius(endCornerRadius, endCornerRadius)
+    val track = RoundRect(
+        rect = Rect(Offset(offset.x, 0f), size = Size(size.width, size.height)),
+        topLeft = startCorner,
+        topRight = endCorner,
+        bottomRight = endCorner,
+        bottomLeft = startCorner,
+    )
+    drawPath(
+        path = Path().apply {
+            addRoundRect(track)
+        },
+        color = color,
+    )
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsTopModernView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsTopModernView.kt
new file mode 100644
index 000000000..5950263aa
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsTopModernView.kt
@@ -0,0 +1,76 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui.controls
+
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.displayCutout
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.foundation.layout.union
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.copy
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@Composable
+fun ControlsTopModernView(
+    modifier: Modifier = Modifier,
+    title: String,
+    onBackClick: () -> Unit,
+    onMenuClick: () -> Unit,
+) {
+    val systemBarsPadding = WindowInsets.systemBars.union(WindowInsets.displayCutout).asPaddingValues()
+    Row(
+        modifier = modifier
+            .fillMaxWidth()
+            .padding(systemBarsPadding.copy(bottom = 0.dp))
+            .padding(horizontal = 4.dp, vertical = 4.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        IconButton(
+            modifier = Modifier.testTag("btn_back"),
+            onClick = onBackClick,
+        ) {
+            Icon(
+                modifier = Modifier.size(24.dp),
+                imageVector = NextIcons.ArrowBack,
+                contentDescription = stringResource(R.string.navigate_up),
+                tint = Color.White,
+            )
+        }
+        Text(
+            modifier = Modifier
+                .weight(1f)
+                .padding(horizontal = 8.dp),
+            text = title,
+            style = MaterialTheme.typography.titleMedium,
+            color = Color.White,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+        IconButton(
+            modifier = Modifier.testTag("btn_menu"),
+            onClick = onMenuClick,
+        ) {
+            Icon(
+                modifier = Modifier.size(24.dp),
+                imageVector = NextIcons.Menu,
+                contentDescription = stringResource(R.string.menu),
+                tint = Color.White,
+            )
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsTopView.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsTopView.kt
new file mode 100644
index 000000000..2a296a94c
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/ControlsTopView.kt
@@ -0,0 +1,223 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui.controls
+
+import androidx.annotation.OptIn
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.displayCutout
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.foundation.layout.union
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.key
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import app.gyrolet.mpvrx.exoplayer.core.model.ControlButtonsPosition
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControl
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControlZone
+import app.gyrolet.mpvrx.exoplayer.core.model.VideoContentScale
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.copy
+import app.gyrolet.mpvrx.exoplayer.feature.player.AnimatedPlayerControlPlacement
+import app.gyrolet.mpvrx.exoplayer.feature.player.buttons.PlayerButton
+import app.gyrolet.mpvrx.exoplayer.feature.player.playerControlDragSource
+import app.gyrolet.mpvrx.exoplayer.feature.player.playerControlZoneTarget
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SleepTimerState
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@OptIn(UnstableApi::class)
+@Composable
+fun ControlsTopView(
+    modifier: Modifier = Modifier,
+    title: String,
+    player: Player,
+    topRightControls: List<PlayerControl>,
+    controlButtonsPosition: ControlButtonsPosition,
+    visiblePlayerControls: Set<PlayerControl>,
+    videoContentScale: VideoContentScale,
+    isPipSupported: Boolean,
+    isTakingScreenshot: Boolean,
+    itemBounds: MutableMap<PlayerControl, Rect>,
+    zoneBounds: MutableMap<PlayerControlZone, Rect>,
+    isCustomizingControls: Boolean = false,
+    shouldHideLabels: Boolean = false,
+    draggingControl: PlayerControl? = null,
+    onControlDropDragged: (PlayerControl, Offset) -> Unit = { _, _ -> },
+    onControlDragStarted: (PlayerControl) -> Unit = {},
+    onControlDragMoved: (PlayerControl, Offset) -> Unit = { _, _ -> },
+    onControlDragCancelled: (PlayerControl) -> Unit = {},
+    isBackVisible: Boolean = true,
+    isBackSelected: Boolean = false,
+    isBackInteractive: Boolean = true,
+    onAudioClick: () -> Unit = {},
+    onSubtitleClick: () -> Unit = {},
+    onPlaybackSpeedClick: () -> Unit = {},
+    onPlaylistClick: () -> Unit = {},
+    onLockControlsClick: () -> Unit = {},
+    onVideoContentScaleClick: () -> Unit = {},
+    onVideoContentScaleLongClick: () -> Unit = {},
+    onDecoderClick: () -> Unit = {},
+    onAmbienceModeClick: () -> Unit = {},
+    isAmbienceModeEnabled: Boolean = false,
+    onVideoFiltersClick: () -> Unit = {},
+    onPictureInPictureClick: () -> Unit = {},
+    onRotateClick: () -> Unit = {},
+    onScreenshotClick: () -> Unit = {},
+    onPlayInBackgroundClick: () -> Unit = {},
+    onLoopClick: (() -> Unit)? = null,
+    onShuffleClick: (() -> Unit)? = null,
+    onSleepTimerClick: (() -> Unit)? = null,
+    sleepTimerState: SleepTimerState? = null,
+    onBackClick: () -> Unit,
+) {
+    val systemBarsPadding = WindowInsets.systemBars.union(WindowInsets.displayCutout).asPaddingValues()
+    val isLandscape = LocalConfiguration.current.orientation == android.content.res.Configuration.ORIENTATION_LANDSCAPE
+    val maxVisibleCount = if (isLandscape) 6 else 4
+    val buttonSlotWidth = if (isCustomizingControls) 72.dp else 48.dp
+    val maxRowWidth = buttonSlotWidth * maxVisibleCount
+
+    @Composable
+    fun BackButton() {
+        if (!isBackVisible) return
+
+        PlayerButton(
+            onClick = onBackClick,
+            isSelected = isBackSelected,
+            label = stringResource(R.string.player_controls_exit).takeIf { isCustomizingControls },
+            shouldShowSelectionBadge = false,
+            shouldDimWhenUnselected = false,
+            shouldShowCustomizeFrame = false,
+            isInteractive = isBackInteractive,
+        ) {
+            Icon(
+                imageVector = NextIcons.ArrowBack,
+                contentDescription = "btn_back",
+                tint = Color.White,
+            )
+        }
+    }
+
+    @Composable
+    fun RowScope.Title() {
+        Text(
+            text = title,
+            style = MaterialTheme.typography.titleMedium,
+            color = Color.White,
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis,
+            modifier = Modifier.weight(1f),
+        )
+    }
+
+    @Composable
+    fun TopControls() {
+        Row(
+            modifier = Modifier
+                .widthIn(max = maxRowWidth)
+                .heightIn(min = 72.dp)
+                .then(
+                    when (isCustomizingControls) {
+                        true -> Modifier.playerControlZoneTarget(
+                            zone = PlayerControlZone.TOP_RIGHT,
+                            zoneBounds = zoneBounds,
+                        )
+                        false -> Modifier
+                    },
+                )
+                .horizontalScroll(rememberScrollState()),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            topRightControls.forEach { control ->
+                if (!isCustomizingControls && control !in visiblePlayerControls) return@forEach
+                key(control) {
+                    AnimatedPlayerControlPlacement(
+                        control = control,
+                        itemBounds = itemBounds,
+                        isTracking = isCustomizingControls,
+                    ) {
+                        PlayerCustomizableControlButton(
+                            modifier = Modifier.playerControlDragSource(
+                                control = control,
+                                enabled = isCustomizingControls,
+                                onDropDragged = onControlDropDragged,
+                                onDragStarted = onControlDragStarted,
+                                onDragMoved = onControlDragMoved,
+                                onDragCancelled = onControlDragCancelled,
+                            ),
+                            control = control,
+                            isBeingDragged = draggingControl == control,
+                            player = player,
+                            videoContentScale = videoContentScale,
+                            isPipSupported = isPipSupported,
+                            isCustomizingControls = isCustomizingControls,
+                            shouldHideLabel = shouldHideLabels,
+                            visiblePlayerControls = visiblePlayerControls,
+                            onPlaylistClick = onPlaylistClick,
+                            onPlaybackSpeedClick = onPlaybackSpeedClick,
+                            onAudioClick = onAudioClick,
+                            onSubtitleClick = onSubtitleClick,
+                            onLockControlsClick = onLockControlsClick,
+                            onVideoContentScaleClick = onVideoContentScaleClick,
+                            onVideoContentScaleLongClick = onVideoContentScaleLongClick,
+                            onDecoderClick = onDecoderClick,
+                            onAmbienceModeClick = onAmbienceModeClick,
+                            isAmbienceModeEnabled = isAmbienceModeEnabled,
+                            onVideoFiltersClick = onVideoFiltersClick,
+                            onPictureInPictureClick = onPictureInPictureClick,
+                            onRotateClick = onRotateClick,
+                            isTakingScreenshot = isTakingScreenshot,
+                            onScreenshotClick = onScreenshotClick,
+                            onPlayInBackgroundClick = onPlayInBackgroundClick,
+                            onLoopClick = onLoopClick,
+                            onShuffleClick = onShuffleClick,
+                            onSleepTimerClick = onSleepTimerClick,
+                            sleepTimerState = sleepTimerState,
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    Row(
+        modifier = modifier
+            .padding(systemBarsPadding.copy(bottom = 0.dp))
+            .padding(horizontal = 8.dp)
+            .padding(bottom = 16.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        when (controlButtonsPosition) {
+            ControlButtonsPosition.LEFT -> {
+                BackButton()
+                Title()
+                TopControls()
+            }
+            ControlButtonsPosition.RIGHT -> {
+                TopControls()
+                Title()
+                BackButton()
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/PlayerCustomizableControlButton.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/PlayerCustomizableControlButton.kt
new file mode 100644
index 000000000..8ef53efa6
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/ui/controls/PlayerCustomizableControlButton.kt
@@ -0,0 +1,387 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.ui.controls
+
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.media3.common.Player
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControl
+import app.gyrolet.mpvrx.exoplayer.core.model.VideoContentScale
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.feature.player.buttons.LoopButton
+import app.gyrolet.mpvrx.exoplayer.feature.player.buttons.PlayerButton
+import app.gyrolet.mpvrx.exoplayer.feature.player.buttons.ShuffleButton
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.nameRes
+import app.gyrolet.mpvrx.exoplayer.feature.player.state.SleepTimerState
+import app.gyrolet.mpvrx.ui.icons.Icon
+
+@Composable
+internal fun PlayerCustomizableControlButton(
+    modifier: Modifier = Modifier,
+    control: PlayerControl,
+    player: Player,
+    videoContentScale: VideoContentScale,
+    isPipSupported: Boolean,
+    isCustomizingControls: Boolean,
+    visiblePlayerControls: Set<PlayerControl>,
+    isBeingDragged: Boolean = false,
+    isOutlineOnly: Boolean = false,
+    shouldHideLabel: Boolean = false,
+    onPlaylistClick: () -> Unit,
+    onPlaybackSpeedClick: () -> Unit,
+    onAudioClick: () -> Unit,
+    onSubtitleClick: () -> Unit,
+    onLockControlsClick: () -> Unit,
+    onVideoContentScaleClick: () -> Unit,
+    onVideoContentScaleLongClick: () -> Unit,
+    onDecoderClick: () -> Unit,
+    onAmbienceModeClick: () -> Unit,
+    isAmbienceModeEnabled: Boolean,
+    onVideoFiltersClick: () -> Unit,
+    onPictureInPictureClick: () -> Unit,
+    onRotateClick: () -> Unit,
+    isTakingScreenshot: Boolean,
+    onScreenshotClick: () -> Unit,
+    onPlayInBackgroundClick: () -> Unit,
+    onLoopClick: (() -> Unit)? = null,
+    onShuffleClick: (() -> Unit)? = null,
+    onSleepTimerClick: (() -> Unit)? = null,
+    sleepTimerState: SleepTimerState? = null,
+) {
+    if (!isCustomizingControls && control !in visiblePlayerControls) return
+    if (!isCustomizingControls && control == PlayerControl.PIP && !isPipSupported) return
+
+    val isSelected = isCustomizingControls && control in visiblePlayerControls
+    val isPlaceholder = isBeingDragged || isOutlineOnly
+    val shouldShowLabel = isCustomizingControls || !shouldHideLabel
+    val label = control.label().takeIf { shouldShowLabel }
+    val buttonModifier = modifier
+
+    when (control) {
+        PlayerControl.PLAYLIST -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onPlaylistClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.PlaylistPlay,
+                    contentDescription = "btn_playlist",
+                )
+            }
+        }
+
+        PlayerControl.PLAYBACK_SPEED -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onPlaybackSpeedClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Speed,
+                    contentDescription = "btn_speed",
+                )
+            }
+        }
+
+        PlayerControl.AUDIO -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onAudioClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Audio,
+                    contentDescription = "btn_audio",
+                )
+            }
+        }
+
+        PlayerControl.SUBTITLE -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onSubtitleClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Subtitle,
+                    contentDescription = "btn_subtitle",
+                )
+            }
+        }
+
+        PlayerControl.LOCK -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onLockControlsClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Lock,
+                    contentDescription = "btn_lock",
+                )
+            }
+        }
+
+        PlayerControl.SCALE -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onVideoContentScaleClick,
+                onLongClick = onVideoContentScaleLongClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Frame,
+                    contentDescription = "btn_scale",
+                )
+            }
+        }
+
+        PlayerControl.DECODER -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onDecoderClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Decoder,
+                    contentDescription = "btn_decoder",
+                )
+            }
+        }
+
+        PlayerControl.AMBIENCE_MODE -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onAmbienceModeClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = if (isAmbienceModeEnabled) NextIcons.Frame else NextIcons.Background,
+                    contentDescription = "btn_ambience_mode",
+                )
+            }
+        }
+
+        PlayerControl.VIDEO_FILTERS -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onVideoFiltersClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Sensitivity,
+                    contentDescription = "btn_video_filters",
+                )
+            }
+        }
+
+        PlayerControl.PIP -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onPictureInPictureClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Pip,
+                    contentDescription = "btn_pip",
+                )
+            }
+        }
+
+        PlayerControl.SCREENSHOT -> {
+            PlayerButton(
+                modifier = buttonModifier.alpha(if (isTakingScreenshot) 0.5f else 1f),
+                onClick = onScreenshotClick,
+                isSelected = isSelected,
+                isEnabled = !isTakingScreenshot,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                if (isTakingScreenshot) {
+                    CircularProgressIndicator(
+                        modifier = Modifier.size(20.dp),
+                        strokeWidth = 2.dp,
+                    )
+                } else {
+                    Icon(
+                        imageVector = NextIcons.Screenshot,
+                        contentDescription = "btn_screenshot",
+                    )
+                }
+            }
+        }
+
+        PlayerControl.BACKGROUND_PLAY -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onPlayInBackgroundClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Headset,
+                    contentDescription = "btn_background",
+                )
+            }
+        }
+
+        PlayerControl.LOOP -> {
+            LoopButton(
+                player = player,
+                modifier = buttonModifier,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+                onClick = onLoopClick.takeIf { isCustomizingControls },
+            )
+        }
+
+        PlayerControl.SHUFFLE -> {
+            ShuffleButton(
+                player = player,
+                modifier = buttonModifier,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+                onClick = onShuffleClick.takeIf { isCustomizingControls },
+            )
+        }
+
+        PlayerControl.SLEEP_TIMER -> {
+            val isSleepTimerActive = sleepTimerState?.isActive == true
+            PlayerButton(
+                modifier = buttonModifier,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+                onClick = {
+                    onSleepTimerClick?.invoke()
+                },
+            ) {
+                if (isSleepTimerActive) {
+                    val remainingMillis = sleepTimerState.remainingMillis
+                    val remainingMin = ((remainingMillis + 59_999) / 60_000).toInt()
+                    Text(
+                        text = "$remainingMin",
+                        style = MaterialTheme.typography.labelSmall,
+                        fontWeight = FontWeight.Bold,
+                        maxLines = 1,
+                    )
+                } else {
+                    Icon(
+                        imageVector = NextIcons.Timer,
+                        contentDescription = "btn_sleep_timer",
+                    )
+                }
+            }
+        }
+
+        PlayerControl.ROTATE -> {
+            PlayerButton(
+                modifier = buttonModifier,
+                onClick = onRotateClick,
+                isSelected = isSelected,
+                label = label,
+                shouldDimWhenUnselected = isCustomizingControls,
+                shouldShowCustomizeFrame = isCustomizingControls,
+                isOutlineOnly = isPlaceholder,
+            ) {
+                Icon(
+                    imageVector = NextIcons.Rotation,
+                    contentDescription = "btn_rotate",
+                )
+            }
+        }
+
+        PlayerControl.BACK,
+        PlayerControl.PREVIOUS,
+        PlayerControl.PLAY_PAUSE,
+        PlayerControl.NEXT,
+        -> Unit
+    }
+}
+
+@Composable
+private fun PlayerControl.label(): String = when (this) {
+    PlayerControl.PLAYLIST -> stringResource(R.string.now_playing)
+    PlayerControl.PLAYBACK_SPEED -> stringResource(R.string.exo_speed)
+    PlayerControl.AUDIO -> stringResource(R.string.exo_audio)
+    PlayerControl.SUBTITLE -> stringResource(R.string.subtitle)
+    PlayerControl.LOCK -> stringResource(R.string.controls_lock)
+    PlayerControl.SCALE -> stringResource(R.string.video_zoom)
+    PlayerControl.DECODER -> stringResource(R.string.decoder)
+    PlayerControl.AMBIENCE_MODE -> stringResource(R.string.ambience_mode)
+    PlayerControl.VIDEO_FILTERS -> stringResource(R.string.video_filters)
+    PlayerControl.PIP -> stringResource(R.string.pip_settings)
+    PlayerControl.SCREENSHOT -> stringResource(R.string.take_screenshot)
+    PlayerControl.BACKGROUND_PLAY -> stringResource(R.string.background_play)
+    PlayerControl.LOOP -> stringResource(R.string.loop_mode)
+    PlayerControl.SHUFFLE -> stringResource(R.string.shuffle)
+    PlayerControl.SLEEP_TIMER -> stringResource(R.string.exo_sleep_timer)
+    PlayerControl.ROTATE -> stringResource(R.string.screen_rotation)
+    PlayerControl.BACK,
+    PlayerControl.PREVIOUS,
+    PlayerControl.PLAY_PAUSE,
+    PlayerControl.NEXT,
+    -> ""
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/utils/PlayerApi.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/utils/PlayerApi.kt
new file mode 100644
index 000000000..1a81b1de6
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/feature/player/utils/PlayerApi.kt
@@ -0,0 +1,73 @@
+package app.gyrolet.mpvrx.exoplayer.feature.player.utils
+
+import android.content.Intent
+import android.net.Uri
+import androidx.media3.common.C
+import app.gyrolet.mpvrx.exoplayer.ExoPlayerActivity
+import app.gyrolet.mpvrx.exoplayer.feature.player.extensions.getParcelableUriArray
+import app.gyrolet.mpvrx.exoplayer.feature.player.model.Subtitle
+
+class PlayerApi(val activity: ExoPlayerActivity) {
+
+    private val extras = activity.intent.extras
+    val isApiAccess: Boolean get() = extras != null
+    val hasPosition: Boolean get() = extras?.containsKey(API_POSITION) == true
+    val hasTitle: Boolean get() = extras?.containsKey(API_TITLE) == true
+    val shouldReturnResult: Boolean get() = extras?.containsKey(API_RETURN_RESULT) == true
+    val position: Int? get() = if (hasPosition) extras?.getInt(API_POSITION) else null
+    val title: String? get() = if (hasTitle) extras?.getString(API_TITLE) else null
+
+    fun getSubs(): List<Subtitle> {
+        if (extras == null) return emptyList()
+        if (!extras.containsKey(API_SUBS)) return emptyList()
+
+        val subs = extras.getParcelableUriArray(API_SUBS) ?: return emptyList()
+        val subsName = extras.getStringArray(API_SUBS_NAME)
+
+        val subsEnable = extras.getParcelableUriArray(API_SUBS_ENABLE)
+        val defaultSub = if (!subsEnable.isNullOrEmpty()) subsEnable[0] else null
+
+        return subs.mapIndexed { index, subtitleUri ->
+            val subtitleName = subsName?.let { if (it.size > index) it[index] else null }
+            Subtitle(
+                name = subtitleName,
+                uri = subtitleUri,
+                isSelected = subtitleUri == defaultSub,
+            )
+        }
+    }
+
+    fun getPlaylist(): List<String> {
+        if (extras == null) return emptyList()
+        if (!extras.containsKey(API_PLAYLIST)) return emptyList()
+        val playlist = extras.getParcelableUriArray(API_PLAYLIST) ?: return emptyList()
+        return playlist.map(Uri::toString)
+    }
+
+    fun getResult(isPlaybackFinished: Boolean, duration: Long, position: Long): Intent = Intent(API_RESULT_INTENT).apply {
+        if (isPlaybackFinished) {
+            putExtra(API_END_BY, API_END_BY_COMPLETION)
+        } else {
+            putExtra(API_END_BY, API_END_BY_USER)
+            if (duration != C.TIME_UNSET) putExtra(API_DURATION, duration.toInt())
+            if (position != C.TIME_UNSET) putExtra(API_POSITION, position.toInt())
+        }
+    }
+
+    companion object {
+        const val API_TITLE = "title"
+        const val API_POSITION = "position"
+        const val API_DURATION = "duration"
+        const val API_RETURN_RESULT = "return_result"
+        const val API_END_BY = "end_by"
+        const val API_SUBS = "subs"
+        const val API_SUBS_ENABLE = "subs.enable"
+        const val API_SUBS_NAME = "subs.name"
+        const val API_PLAYLIST = "video_list"
+
+        const val API_RESULT_INTENT = "com.mxtech.intent.result.VIEW"
+
+        private const val API_END_BY_USER = "user"
+        private const val API_END_BY_COMPLETION = "playback_completion"
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/extensions/Extensions.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/extensions/Extensions.kt
new file mode 100644
index 000000000..3089f0dfb
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/extensions/Extensions.kt
@@ -0,0 +1,91 @@
+package app.gyrolet.mpvrx.exoplayer.settings.extensions
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import app.gyrolet.mpvrx.exoplayer.core.model.ControlButtonsPosition
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+import app.gyrolet.mpvrx.exoplayer.core.model.DoubleTapGesture
+import app.gyrolet.mpvrx.exoplayer.core.model.Font
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControlsStyle
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerIconStyle
+import app.gyrolet.mpvrx.exoplayer.core.model.Resume
+import app.gyrolet.mpvrx.exoplayer.core.model.ScreenOrientation
+import app.gyrolet.mpvrx.R
+
+@Composable
+fun ScreenOrientation.name(): String {
+    val stringRes = when (this) {
+        ScreenOrientation.AUTOMATIC -> R.string.automatic
+        ScreenOrientation.LANDSCAPE -> R.string.landscape
+        ScreenOrientation.LANDSCAPE_REVERSE -> R.string.landscape_reverse
+        ScreenOrientation.LANDSCAPE_AUTO -> R.string.landscape_auto
+        ScreenOrientation.PORTRAIT -> R.string.portrait
+        ScreenOrientation.VIDEO_ORIENTATION -> R.string.video_orientation
+    }
+    return stringResource(id = stringRes)
+}
+
+@Composable
+fun PlayerControlsStyle.name(): String {
+    val stringRes = when (this) {
+        PlayerControlsStyle.LEGACY -> R.string.player_controls_style_legacy
+        PlayerControlsStyle.MODERN -> R.string.player_controls_style_modern
+    }
+    return stringResource(stringRes)
+}
+
+@Composable
+fun PlayerIconStyle.name(): String {
+    val stringRes = when (this) {
+        PlayerIconStyle.TONAL -> R.string.player_icon_style_tonal
+        PlayerIconStyle.CLASSIC -> R.string.player_icon_style_classic
+        PlayerIconStyle.TRANSLUCENT -> R.string.player_icon_style_translucent
+    }
+    return stringResource(stringRes)
+}
+
+@Composable
+fun ControlButtonsPosition.name(): String {
+    val stringRes = when (this) {
+        ControlButtonsPosition.LEFT -> R.string.control_buttons_alignment_left
+        ControlButtonsPosition.RIGHT -> R.string.control_buttons_alignment_right
+    }
+    return stringResource(stringRes)
+}
+
+@Composable
+fun DoubleTapGesture.name(): String {
+    val stringRes = when (this) {
+        DoubleTapGesture.NONE -> R.string.off
+        DoubleTapGesture.FAST_FORWARD_AND_REWIND -> R.string.ff_rewind
+        DoubleTapGesture.PLAY_PAUSE -> R.string.play_pause
+        DoubleTapGesture.BOTH -> R.string.play_pause_ff_rewind
+    }
+    return stringResource(stringRes)
+}
+
+@Composable
+fun DecoderPriority.name(): String {
+    val stringRes = when (this) {
+        DecoderPriority.AUTOMATIC -> R.string.auto
+        DecoderPriority.AUTOMATIC_PREFER_DEVICE -> R.string.auto_hw_decoder
+        DecoderPriority.DEVICE_ONLY -> R.string.device_decoders_only
+        DecoderPriority.PREFER_DEVICE -> R.string.prefer_device_decoders
+        DecoderPriority.PREFER_APP -> R.string.prefer_app_decoders
+    }
+    return stringResource(stringRes)
+}
+
+@Composable
+fun Font.name(): String {
+    val stringRes = when (this) {
+        Font.DEFAULT -> R.string.default_name
+        Font.SANS_SERIF -> R.string.sans_serif
+        Font.SERIF -> R.string.serif
+        Font.MONOSPACE -> R.string.monospace
+    }
+    return stringResource(stringRes)
+}
+
+val Resume.isEnabled: Boolean
+    get() = this == Resume.YES
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/audio/AudioPreferencesScreen.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/audio/AudioPreferencesScreen.kt
new file mode 100644
index 000000000..2006ea646
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/audio/AudioPreferencesScreen.kt
@@ -0,0 +1,246 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.audio
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledIconButton
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ClickablePreferenceItem
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ListSectionTitle
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextTopAppBar
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.OptionsDialog
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSlider
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSwitch
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.RadioTextButton
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.withBottomFallback
+import app.gyrolet.mpvrx.exoplayer.settings.utils.LocalesHelper
+import app.gyrolet.mpvrx.presentation.Screen
+import app.gyrolet.mpvrx.ui.icons.Icon
+import app.gyrolet.mpvrx.ui.utils.LocalBackStack
+import app.gyrolet.mpvrx.ui.utils.popSafely
+import kotlinx.serialization.Serializable
+import org.koin.compose.viewmodel.koinViewModel
+
+@Serializable
+object ExoAudioPreferencesScreen : Screen {
+    @Composable
+    override fun Content() {
+        val backstack = LocalBackStack.current
+        AudioPreferencesScreen(
+            onNavigateUp = { backstack.popSafely() }
+        )
+    }
+}
+
+@Composable
+fun AudioPreferencesScreen(
+    onNavigateUp: () -> Unit,
+    viewModel: AudioPreferencesViewModel = koinViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    AudioPreferencesContent(
+        uiState = uiState,
+        onEvent = viewModel::onEvent,
+        onNavigateUp = onNavigateUp,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun AudioPreferencesContent(
+    uiState: AudioPreferencesUiState,
+    onEvent: (AudioPreferencesUiEvent) -> Unit,
+    onNavigateUp: () -> Unit,
+) {
+    val languages = remember { listOf(Pair("None", "")) + LocalesHelper.getAvailableLocales() }
+    val initialVolumeLimitRange = PlayerPreferences.MIN_INITIAL_PLAYER_VOLUME_PERCENTAGE.toFloat().rangeTo(
+        PlayerPreferences.MAX_INITIAL_PLAYER_VOLUME_PERCENTAGE.toFloat(),
+    )
+
+    Scaffold(
+        topBar = {
+            NextTopAppBar(
+                title = stringResource(id = R.string.exo_audio),
+                navigationIcon = {
+                    FilledTonalIconButton(onClick = onNavigateUp) {
+                        Icon(
+                            imageVector = NextIcons.ArrowBack,
+                            contentDescription = stringResource(id = R.string.generic_cancel),
+                        )
+                    }
+                },
+            )
+        },
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .verticalScroll(state = rememberScrollState())
+                .padding(innerPadding.withBottomFallback())
+                .padding(horizontal = 16.dp),
+        ) {
+            ListSectionTitle(text = stringResource(id = R.string.audio_track_settings))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_audio_language"),
+                    title = stringResource(id = R.string.preferred_audio_lang),
+                    description = LocalesHelper.getLocaleDisplayLanguage(uiState.preferences.preferredAudioLanguage)
+                        .takeIf { it.isNotBlank() } ?: stringResource(R.string.preferred_audio_lang_description),
+                    icon = NextIcons.Language,
+                    onClick = { onEvent(AudioPreferencesUiEvent.ShowDialog(AudioPreferenceDialog.AudioLanguageDialog)) },
+                    isFirstItem = true,
+                    isLastItem = true,
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.audio_focus_and_devices))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_audio_require_focus"),
+                    title = stringResource(R.string.require_audio_focus),
+                    description = stringResource(R.string.require_audio_focus_desc),
+                    icon = NextIcons.Focus,
+                    isChecked = uiState.preferences.shouldRequireAudioFocus,
+                    onClick = { onEvent(AudioPreferencesUiEvent.ToggleRequireAudioFocus) },
+                    isFirstItem = true,
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_audio_pause_on_headset_disconnect"),
+                    title = stringResource(id = R.string.pause_on_headset_disconnect),
+                    description = stringResource(id = R.string.pause_on_headset_disconnect_desc),
+                    icon = NextIcons.HeadsetOff,
+                    isChecked = uiState.preferences.shouldPauseOnHeadsetDisconnect,
+                    onClick = { onEvent(AudioPreferencesUiEvent.TogglePauseOnHeadsetDisconnect) },
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_audio_system_volume_panel"),
+                    title = stringResource(id = R.string.system_volume_panel),
+                    description = stringResource(id = R.string.system_volume_panel_desc),
+                    icon = NextIcons.Headset,
+                    isChecked = uiState.preferences.shouldShowSystemVolumePanel,
+                    onClick = { onEvent(AudioPreferencesUiEvent.ToggleShowSystemVolumePanel) },
+                    isLastItem = true,
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.volume_memory))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_audio_remember_volume"),
+                    title = stringResource(id = R.string.remember_volume_level),
+                    description = stringResource(id = R.string.remember_volume_level_description),
+                    icon = NextIcons.VolumeUp,
+                    isChecked = uiState.preferences.shouldRememberPlayerVolume,
+                    onClick = { onEvent(AudioPreferencesUiEvent.ToggleRememberPlayerVolume) },
+                    isFirstItem = true,
+                )
+                PreferenceSlider(
+                    modifier = Modifier.testTag("item_settings_audio_initial_volume_limit"),
+                    sliderModifier = Modifier.testTag("slider_settings_audio_initial_volume_limit"),
+                    title = stringResource(id = R.string.initial_volume_limit),
+                    description = stringResource(id = R.string.exo_percent, uiState.preferences.maxInitialPlayerVolumePercentage),
+                    icon = NextIcons.VolumeUp,
+                    isEnabled = uiState.preferences.shouldRememberPlayerVolume,
+                    value = uiState.preferences.maxInitialPlayerVolumePercentage.toFloat(),
+                    valueRange = initialVolumeLimitRange,
+                    onValueChange = { onEvent(AudioPreferencesUiEvent.UpdateMaxInitialPlayerVolume(it.toInt())) },
+                    isLastItem = true,
+                    trailingContent = {
+                        FilledIconButton(
+                            modifier = Modifier.testTag("btn_reset_settings_audio_initial_volume_limit"),
+                            enabled = uiState.preferences.shouldRememberPlayerVolume,
+                            onClick = {
+                                onEvent(
+                                    AudioPreferencesUiEvent.UpdateMaxInitialPlayerVolume(
+                                        PlayerPreferences.DEFAULT_MAX_INITIAL_PLAYER_VOLUME_PERCENTAGE,
+                                    ),
+                                )
+                            },
+                        ) {
+                            Icon(
+                                imageVector = NextIcons.History,
+                                contentDescription = stringResource(id = R.string.generic_reset),
+                            )
+                        }
+                    },
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.volume_processing))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_audio_normalization"),
+                    title = stringResource(id = R.string.volume_normalization),
+                    description = stringResource(id = R.string.volume_normalization_desc),
+                    icon = NextIcons.VolumeUp,
+                    isChecked = uiState.preferences.isVolumeNormalizationEnabled,
+                    onClick = { onEvent(AudioPreferencesUiEvent.ToggleVolumeNormalization) },
+                    isFirstItem = true,
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_audio_boost"),
+                    title = stringResource(id = R.string.volume_boost),
+                    description = stringResource(id = R.string.volume_boost_desc),
+                    icon = NextIcons.VolumeUp,
+                    isChecked = uiState.preferences.isVolumeBoostEnabled,
+                    onClick = { onEvent(AudioPreferencesUiEvent.ToggleVolumeBoost) },
+                    isLastItem = true,
+                )
+            }
+        }
+
+        uiState.showDialog?.let { showDialog ->
+            when (showDialog) {
+                AudioPreferenceDialog.AudioLanguageDialog -> {
+                    OptionsDialog(
+                        title = stringResource(id = R.string.preferred_audio_lang),
+                        onDismissClick = { onEvent(AudioPreferencesUiEvent.ShowDialog(null)) },
+                    ) {
+                        items(languages) {
+                            RadioTextButton(
+                                modifier = Modifier.testTag("option_settings_audio_language_${it.second.ifBlank { "none" }}"),
+                                text = it.first,
+                                isSelected = it.second == uiState.preferences.preferredAudioLanguage,
+                                onClick = {
+                                    onEvent(AudioPreferencesUiEvent.UpdateAudioLanguage(it.second))
+                                    onEvent(AudioPreferencesUiEvent.ShowDialog(null))
+                                },
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/audio/AudioPreferencesViewModel.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/audio/AudioPreferencesViewModel.kt
new file mode 100644
index 000000000..09746581b
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/audio/AudioPreferencesViewModel.kt
@@ -0,0 +1,144 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.audio
+
+import androidx.compose.runtime.Stable
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+
+class AudioPreferencesViewModel(
+    private val preferencesRepository: PreferencesRepository,
+) : ViewModel() {
+
+    private val uiStateInternal = MutableStateFlow(
+        AudioPreferencesUiState(
+            preferences = preferencesRepository.playerPreferences.value,
+        ),
+    )
+    val uiState = uiStateInternal.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            preferencesRepository.playerPreferences.collect { preferences ->
+                uiStateInternal.update { currentState ->
+                    currentState.copy(preferences = preferences)
+                }
+            }
+        }
+    }
+
+    fun onEvent(event: AudioPreferencesUiEvent) {
+        when (event) {
+            is AudioPreferencesUiEvent.ShowDialog -> showDialog(event.value)
+            is AudioPreferencesUiEvent.UpdateAudioLanguage -> updateAudioLanguage(event.value)
+            is AudioPreferencesUiEvent.UpdateMaxInitialPlayerVolume -> updateMaxInitialPlayerVolume(event.value)
+            AudioPreferencesUiEvent.TogglePauseOnHeadsetDisconnect -> togglePauseOnHeadsetDisconnect()
+            AudioPreferencesUiEvent.ToggleShowSystemVolumePanel -> toggleShowSystemVolumePanel()
+            AudioPreferencesUiEvent.ToggleRequireAudioFocus -> toggleRequireAudioFocus()
+            AudioPreferencesUiEvent.ToggleRememberPlayerVolume -> toggleRememberPlayerVolume()
+            AudioPreferencesUiEvent.ToggleVolumeNormalization -> toggleVolumeNormalization()
+            AudioPreferencesUiEvent.ToggleVolumeBoost -> toggleVolumeBoost()
+        }
+    }
+
+    private fun showDialog(value: AudioPreferenceDialog?) {
+        uiStateInternal.update {
+            it.copy(showDialog = value)
+        }
+    }
+
+    private fun updateAudioLanguage(value: String) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(preferredAudioLanguage = value)
+            }
+        }
+    }
+
+    private fun togglePauseOnHeadsetDisconnect() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldPauseOnHeadsetDisconnect = !it.shouldPauseOnHeadsetDisconnect)
+            }
+        }
+    }
+
+    private fun toggleShowSystemVolumePanel() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldShowSystemVolumePanel = !it.shouldShowSystemVolumePanel)
+            }
+        }
+    }
+
+    private fun toggleRequireAudioFocus() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldRequireAudioFocus = !it.shouldRequireAudioFocus)
+            }
+        }
+    }
+
+    private fun toggleRememberPlayerVolume() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldRememberPlayerVolume = !it.shouldRememberPlayerVolume)
+            }
+        }
+    }
+
+    private fun updateMaxInitialPlayerVolume(value: Int) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(
+                    maxInitialPlayerVolumePercentage = value.coerceIn(
+                        PlayerPreferences.MIN_INITIAL_PLAYER_VOLUME_PERCENTAGE,
+                        PlayerPreferences.MAX_INITIAL_PLAYER_VOLUME_PERCENTAGE,
+                    ),
+                )
+            }
+        }
+    }
+
+    private fun toggleVolumeNormalization() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(isVolumeNormalizationEnabled = !it.isVolumeNormalizationEnabled)
+            }
+        }
+    }
+
+    private fun toggleVolumeBoost() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(isVolumeBoostEnabled = !it.isVolumeBoostEnabled)
+            }
+        }
+    }
+}
+
+@Stable
+data class AudioPreferencesUiState(
+    val showDialog: AudioPreferenceDialog? = null,
+    val preferences: PlayerPreferences = PlayerPreferences(),
+)
+
+sealed interface AudioPreferenceDialog {
+    data object AudioLanguageDialog : AudioPreferenceDialog
+}
+
+sealed interface AudioPreferencesUiEvent {
+    data class ShowDialog(val value: AudioPreferenceDialog?) : AudioPreferencesUiEvent
+    data class UpdateAudioLanguage(val value: String) : AudioPreferencesUiEvent
+    data class UpdateMaxInitialPlayerVolume(val value: Int) : AudioPreferencesUiEvent
+    data object TogglePauseOnHeadsetDisconnect : AudioPreferencesUiEvent
+    data object ToggleShowSystemVolumePanel : AudioPreferencesUiEvent
+    data object ToggleRequireAudioFocus : AudioPreferencesUiEvent
+    data object ToggleRememberPlayerVolume : AudioPreferencesUiEvent
+    data object ToggleVolumeNormalization : AudioPreferencesUiEvent
+    data object ToggleVolumeBoost : AudioPreferencesUiEvent
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/decoder/DecoderPreferencesScreen.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/decoder/DecoderPreferencesScreen.kt
new file mode 100644
index 000000000..e7f2bf12e
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/decoder/DecoderPreferencesScreen.kt
@@ -0,0 +1,353 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.decoder
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledIconButton
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ClickablePreferenceItem
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ListSectionTitle
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextSwitch
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextTopAppBar
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.OptionsDialog
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSlider
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSwitch
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.RadioTextButton
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.withBottomFallback
+import app.gyrolet.mpvrx.exoplayer.settings.extensions.name
+import app.gyrolet.mpvrx.presentation.Screen
+import app.gyrolet.mpvrx.ui.icons.Icon
+import app.gyrolet.mpvrx.ui.utils.LocalBackStack
+import app.gyrolet.mpvrx.ui.utils.popSafely
+import kotlinx.serialization.Serializable
+import org.koin.compose.viewmodel.koinViewModel
+
+@Serializable
+object ExoDecoderPreferencesScreen : Screen {
+    @Composable
+    override fun Content() {
+        val backstack = LocalBackStack.current
+        DecoderPreferencesScreen(
+            onNavigateUp = { backstack.popSafely() }
+        )
+    }
+}
+
+@Composable
+fun DecoderPreferencesScreen(
+    onNavigateUp: () -> Unit,
+    viewModel: DecoderPreferencesViewModel = koinViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    DecoderPreferencesContent(
+        uiState = uiState,
+        onEvent = viewModel::onEvent,
+        onNavigateUp = onNavigateUp,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun DecoderPreferencesContent(
+    uiState: DecoderPreferencesUiState,
+    onEvent: (DecoderPreferencesUiEvent) -> Unit,
+    onNavigateUp: () -> Unit,
+) {
+    val preferences = uiState.preferences
+
+    Scaffold(
+        topBar = {
+            NextTopAppBar(
+                title = stringResource(id = R.string.exo_decoder),
+                navigationIcon = {
+                    FilledTonalIconButton(onClick = onNavigateUp) {
+                        Icon(
+                            imageVector = NextIcons.ArrowBack,
+                            contentDescription = stringResource(id = R.string.generic_cancel),
+                        )
+                    }
+                },
+            )
+        },
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .verticalScroll(state = rememberScrollState())
+                .padding(innerPadding.withBottomFallback())
+                .padding(horizontal = 16.dp),
+        ) {
+            ListSectionTitle(text = stringResource(id = R.string.exo_decoder))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_decoder_priority"),
+                    title = stringResource(R.string.decoder_priority),
+                    description = preferences.decoderPriority.name(),
+                    icon = NextIcons.Priority,
+                    onClick = { onEvent(DecoderPreferencesUiEvent.ShowDialog(DecoderPreferenceDialog.DecoderPriorityDialog)) },
+                    isFirstItem = true,
+                    isLastItem = true,
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.video_filters))
+            VideoFiltersSettings(
+                preferences = preferences,
+                onEvent = onEvent,
+            )
+        }
+
+        uiState.showDialog?.let { showDialog ->
+            when (showDialog) {
+                DecoderPreferenceDialog.DecoderPriorityDialog -> {
+                    OptionsDialog(
+                        title = stringResource(id = R.string.decoder_priority),
+                        onDismissClick = { onEvent(DecoderPreferencesUiEvent.ShowDialog(null)) },
+                    ) {
+                        items(DecoderPriority.entries.toTypedArray()) {
+                            RadioTextButton(
+                                modifier = Modifier.testTag("option_settings_decoder_priority_${it.name.lowercase()}"),
+                                text = it.name(),
+                                isSelected = it == preferences.decoderPriority,
+                                onClick = {
+                                    onEvent(DecoderPreferencesUiEvent.UpdateDecoderPriority(it))
+                                    onEvent(DecoderPreferencesUiEvent.ShowDialog(null))
+                                },
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun VideoFiltersSettings(
+    preferences: PlayerPreferences,
+    onEvent: (DecoderPreferencesUiEvent) -> Unit,
+) {
+    Column(
+        verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+    ) {
+        PreferenceSwitch(
+            modifier = Modifier.testTag("switch_settings_video_filters"),
+            title = stringResource(R.string.video_filters),
+            description = stringResource(R.string.enable_video_filters_description),
+            icon = NextIcons.Sensitivity,
+            isChecked = preferences.shouldApplyVideoFilters,
+            onClick = { onEvent(DecoderPreferencesUiEvent.ToggleVideoFilters) },
+            isFirstItem = true,
+        )
+        PreferenceSlider(
+            modifier = Modifier.testTag("item_settings_video_brightness"),
+            sliderModifier = Modifier.testTag("slider_settings_video_brightness"),
+            title = stringResource(R.string.video_brightness),
+            description = signedPercent(preferences.videoBrightness),
+            icon = NextIcons.Sensitivity,
+            isEnabled = preferences.shouldApplyVideoFilters,
+            isSliderEnabled = preferences.shouldApplyVideoFilters && preferences.isVideoBrightnessFilterEnabled,
+            value = preferences.videoBrightness,
+            valueRange = PlayerPreferences.MIN_VIDEO_BRIGHTNESS..PlayerPreferences.MAX_VIDEO_BRIGHTNESS,
+            onValueChange = { onEvent(DecoderPreferencesUiEvent.UpdateVideoBrightness(it)) },
+            trailingContent = {
+                VideoFilterActions(
+                    switchTestTag = "switch_settings_video_brightness",
+                    resetTestTag = "btn_reset_settings_video_brightness",
+                    resetContentDescription = stringResource(id = R.string.generic_reset),
+                    isEnabled = preferences.shouldApplyVideoFilters,
+                    isChecked = preferences.isVideoBrightnessFilterEnabled,
+                    onToggle = { onEvent(DecoderPreferencesUiEvent.ToggleVideoBrightnessFilter) },
+                    onReset = { onEvent(DecoderPreferencesUiEvent.UpdateVideoBrightness(PlayerPreferences.DEFAULT_VIDEO_BRIGHTNESS)) },
+                )
+            },
+        )
+        PreferenceSlider(
+            modifier = Modifier.testTag("item_settings_video_contrast"),
+            sliderModifier = Modifier.testTag("slider_settings_video_contrast"),
+            title = stringResource(R.string.video_contrast),
+            description = signedPercent(preferences.videoContrast),
+            icon = NextIcons.Sensitivity,
+            isEnabled = preferences.shouldApplyVideoFilters,
+            isSliderEnabled = preferences.shouldApplyVideoFilters && preferences.isVideoContrastFilterEnabled,
+            value = preferences.videoContrast,
+            valueRange = PlayerPreferences.MIN_VIDEO_CONTRAST..PlayerPreferences.MAX_VIDEO_CONTRAST,
+            onValueChange = { onEvent(DecoderPreferencesUiEvent.UpdateVideoContrast(it)) },
+            trailingContent = {
+                VideoFilterActions(
+                    switchTestTag = "switch_settings_video_contrast",
+                    resetTestTag = "btn_reset_settings_video_contrast",
+                    resetContentDescription = stringResource(id = R.string.generic_reset),
+                    isEnabled = preferences.shouldApplyVideoFilters,
+                    isChecked = preferences.isVideoContrastFilterEnabled,
+                    onToggle = { onEvent(DecoderPreferencesUiEvent.ToggleVideoContrastFilter) },
+                    onReset = { onEvent(DecoderPreferencesUiEvent.UpdateVideoContrast(PlayerPreferences.DEFAULT_VIDEO_CONTRAST)) },
+                )
+            },
+        )
+        PreferenceSlider(
+            modifier = Modifier.testTag("item_settings_video_saturation"),
+            sliderModifier = Modifier.testTag("slider_settings_video_saturation"),
+            title = stringResource(R.string.video_saturation),
+            description = signedInteger(preferences.videoSaturation),
+            icon = NextIcons.Sensitivity,
+            isEnabled = preferences.shouldApplyVideoFilters,
+            isSliderEnabled = preferences.shouldApplyVideoFilters && preferences.isVideoSaturationFilterEnabled,
+            value = preferences.videoSaturation,
+            valueRange = PlayerPreferences.MIN_VIDEO_SATURATION..PlayerPreferences.MAX_VIDEO_SATURATION,
+            onValueChange = { onEvent(DecoderPreferencesUiEvent.UpdateVideoSaturation(it)) },
+            trailingContent = {
+                VideoFilterActions(
+                    switchTestTag = "switch_settings_video_saturation",
+                    resetTestTag = "btn_reset_settings_video_saturation",
+                    resetContentDescription = stringResource(id = R.string.generic_reset),
+                    isEnabled = preferences.shouldApplyVideoFilters,
+                    isChecked = preferences.isVideoSaturationFilterEnabled,
+                    onToggle = { onEvent(DecoderPreferencesUiEvent.ToggleVideoSaturationFilter) },
+                    onReset = { onEvent(DecoderPreferencesUiEvent.UpdateVideoSaturation(PlayerPreferences.DEFAULT_VIDEO_SATURATION)) },
+                )
+            },
+        )
+        PreferenceSlider(
+            modifier = Modifier.testTag("item_settings_video_hue"),
+            sliderModifier = Modifier.testTag("slider_settings_video_hue"),
+            title = stringResource(R.string.video_hue),
+            description = stringResource(R.string.exo_degrees, preferences.videoHue.toInt()),
+            icon = NextIcons.Sensitivity,
+            isEnabled = preferences.shouldApplyVideoFilters,
+            isSliderEnabled = preferences.shouldApplyVideoFilters && preferences.isVideoHueFilterEnabled,
+            value = preferences.videoHue,
+            valueRange = PlayerPreferences.MIN_VIDEO_HUE..PlayerPreferences.MAX_VIDEO_HUE,
+            onValueChange = { onEvent(DecoderPreferencesUiEvent.UpdateVideoHue(it)) },
+            trailingContent = {
+                VideoFilterActions(
+                    switchTestTag = "switch_settings_video_hue",
+                    resetTestTag = "btn_reset_settings_video_hue",
+                    resetContentDescription = stringResource(id = R.string.generic_reset),
+                    isEnabled = preferences.shouldApplyVideoFilters,
+                    isChecked = preferences.isVideoHueFilterEnabled,
+                    onToggle = { onEvent(DecoderPreferencesUiEvent.ToggleVideoHueFilter) },
+                    onReset = { onEvent(DecoderPreferencesUiEvent.UpdateVideoHue(PlayerPreferences.DEFAULT_VIDEO_HUE)) },
+                )
+            },
+        )
+        PreferenceSlider(
+            modifier = Modifier.testTag("item_settings_video_gamma"),
+            sliderModifier = Modifier.testTag("slider_settings_video_gamma"),
+            title = stringResource(R.string.video_gamma),
+            description = String.format("%.2f", preferences.videoGamma),
+            icon = NextIcons.Sensitivity,
+            isEnabled = preferences.shouldApplyVideoFilters,
+            isSliderEnabled = preferences.shouldApplyVideoFilters && preferences.isVideoGammaFilterEnabled,
+            value = preferences.videoGamma,
+            valueRange = PlayerPreferences.MIN_VIDEO_GAMMA..PlayerPreferences.MAX_VIDEO_GAMMA,
+            onValueChange = { onEvent(DecoderPreferencesUiEvent.UpdateVideoGamma(it)) },
+            trailingContent = {
+                VideoFilterActions(
+                    switchTestTag = "switch_settings_video_gamma",
+                    resetTestTag = "btn_reset_settings_video_gamma",
+                    resetContentDescription = stringResource(id = R.string.generic_reset),
+                    isEnabled = preferences.shouldApplyVideoFilters,
+                    isChecked = preferences.isVideoGammaFilterEnabled,
+                    onToggle = { onEvent(DecoderPreferencesUiEvent.ToggleVideoGammaFilter) },
+                    onReset = { onEvent(DecoderPreferencesUiEvent.UpdateVideoGamma(PlayerPreferences.DEFAULT_VIDEO_GAMMA)) },
+                )
+            },
+        )
+        PreferenceSlider(
+            modifier = Modifier.testTag("item_settings_video_sharpening"),
+            sliderModifier = Modifier.testTag("slider_settings_video_sharpening"),
+            title = stringResource(R.string.video_sharpening),
+            description = stringResource(R.string.exo_percent, (preferences.videoSharpening * 100).toInt()),
+            icon = NextIcons.Sensitivity,
+            isEnabled = preferences.shouldApplyVideoFilters,
+            isSliderEnabled = preferences.shouldApplyVideoFilters && preferences.isVideoSharpeningFilterEnabled,
+            value = preferences.videoSharpening,
+            valueRange = PlayerPreferences.DEFAULT_VIDEO_SHARPENING..PlayerPreferences.MAX_VIDEO_SHARPENING,
+            onValueChange = { onEvent(DecoderPreferencesUiEvent.UpdateVideoSharpening(it)) },
+            isLastItem = true,
+            trailingContent = {
+                VideoFilterActions(
+                    switchTestTag = "switch_settings_video_sharpening",
+                    resetTestTag = "btn_reset_settings_video_sharpening",
+                    resetContentDescription = stringResource(id = R.string.generic_reset),
+                    isEnabled = preferences.shouldApplyVideoFilters,
+                    isChecked = preferences.isVideoSharpeningFilterEnabled,
+                    onToggle = { onEvent(DecoderPreferencesUiEvent.ToggleVideoSharpeningFilter) },
+                    onReset = { onEvent(DecoderPreferencesUiEvent.UpdateVideoSharpening(PlayerPreferences.DEFAULT_VIDEO_SHARPENING)) },
+                )
+            },
+        )
+    }
+}
+
+@Composable
+private fun VideoFilterActions(
+    switchTestTag: String,
+    resetTestTag: String,
+    resetContentDescription: String,
+    isEnabled: Boolean,
+    isChecked: Boolean,
+    onToggle: () -> Unit,
+    onReset: () -> Unit,
+) {
+    Row(
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        NextSwitch(
+            modifier = Modifier.testTag(switchTestTag),
+            isChecked = isChecked,
+            onCheckedChange = { onToggle() },
+            isEnabled = isEnabled,
+        )
+        FilledIconButton(
+            modifier = Modifier.testTag(resetTestTag),
+            enabled = isEnabled,
+            onClick = onReset,
+        ) {
+            Icon(
+                imageVector = NextIcons.History,
+                contentDescription = resetContentDescription,
+            )
+        }
+    }
+}
+
+private fun signedPercent(value: Float): String {
+    val percent = (value * 100).toInt()
+    return if (percent > 0) "+$percent%" else "$percent%"
+}
+
+private fun signedInteger(value: Float): String {
+    val rounded = value.toInt()
+    return if (rounded > 0) "+$rounded" else "$rounded"
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/decoder/DecoderPreferencesViewModel.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/decoder/DecoderPreferencesViewModel.kt
new file mode 100644
index 000000000..598cd66b1
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/decoder/DecoderPreferencesViewModel.kt
@@ -0,0 +1,186 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.decoder
+
+import androidx.compose.runtime.Stable
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.round
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.model.DecoderPriority
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+
+class DecoderPreferencesViewModel(
+    private val preferencesRepository: PreferencesRepository,
+) : ViewModel() {
+
+    private companion object {
+        const val TAG = "DecoderPreferencesViewModel"
+    }
+
+    private val uiStateInternal = MutableStateFlow(
+        DecoderPreferencesUiState(
+            preferences = preferencesRepository.playerPreferences.value,
+        ),
+    )
+    val uiState = uiStateInternal.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            preferencesRepository.playerPreferences.collect { preferences ->
+                uiStateInternal.update { currentState ->
+                    currentState.copy(preferences = preferences)
+                }
+            }
+        }
+    }
+
+    fun onEvent(event: DecoderPreferencesUiEvent) {
+        when (event) {
+            is DecoderPreferencesUiEvent.ShowDialog -> showDialog(event.value)
+            is DecoderPreferencesUiEvent.UpdateDecoderPriority -> updateDecoderPriority(event.value)
+            DecoderPreferencesUiEvent.ToggleVideoFilters -> toggleVideoFilters()
+            DecoderPreferencesUiEvent.ToggleVideoBrightnessFilter -> toggleVideoBrightnessFilter()
+            is DecoderPreferencesUiEvent.UpdateVideoBrightness -> updateVideoBrightness(event.value)
+            DecoderPreferencesUiEvent.ToggleVideoContrastFilter -> toggleVideoContrastFilter()
+            is DecoderPreferencesUiEvent.UpdateVideoContrast -> updateVideoContrast(event.value)
+            DecoderPreferencesUiEvent.ToggleVideoSaturationFilter -> toggleVideoSaturationFilter()
+            is DecoderPreferencesUiEvent.UpdateVideoSaturation -> updateVideoSaturation(event.value)
+            DecoderPreferencesUiEvent.ToggleVideoHueFilter -> toggleVideoHueFilter()
+            is DecoderPreferencesUiEvent.UpdateVideoHue -> updateVideoHue(event.value)
+            DecoderPreferencesUiEvent.ToggleVideoGammaFilter -> toggleVideoGammaFilter()
+            is DecoderPreferencesUiEvent.UpdateVideoGamma -> updateVideoGamma(event.value)
+            DecoderPreferencesUiEvent.ToggleVideoSharpeningFilter -> toggleVideoSharpeningFilter()
+            is DecoderPreferencesUiEvent.UpdateVideoSharpening -> updateVideoSharpening(event.value)
+        }
+    }
+
+    private fun showDialog(value: DecoderPreferenceDialog?) {
+        uiStateInternal.update {
+            it.copy(showDialog = value)
+        }
+    }
+
+    private fun updateDecoderPriority(value: DecoderPriority) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(decoderPriority = value)
+            }
+        }
+    }
+
+    private fun toggleVideoFilters() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldApplyVideoFilters = !it.shouldApplyVideoFilters)
+            }
+        }
+    }
+
+    private fun toggleVideoBrightnessFilter() {
+        updateVideoFilter("brightness enabled toggled") { preferences ->
+            preferences.copy(isVideoBrightnessFilterEnabled = !preferences.isVideoBrightnessFilterEnabled)
+        }
+    }
+
+    private fun toggleVideoContrastFilter() {
+        updateVideoFilter("contrast enabled toggled") { preferences ->
+            preferences.copy(isVideoContrastFilterEnabled = !preferences.isVideoContrastFilterEnabled)
+        }
+    }
+
+    private fun toggleVideoSaturationFilter() {
+        updateVideoFilter("saturation enabled toggled") { preferences ->
+            preferences.copy(isVideoSaturationFilterEnabled = !preferences.isVideoSaturationFilterEnabled)
+        }
+    }
+
+    private fun toggleVideoHueFilter() {
+        updateVideoFilter("hue enabled toggled") { preferences ->
+            preferences.copy(isVideoHueFilterEnabled = !preferences.isVideoHueFilterEnabled)
+        }
+    }
+
+    private fun toggleVideoGammaFilter() {
+        updateVideoFilter("gamma enabled toggled") { preferences ->
+            preferences.copy(isVideoGammaFilterEnabled = !preferences.isVideoGammaFilterEnabled)
+        }
+    }
+
+    private fun toggleVideoSharpeningFilter() {
+        updateVideoFilter("sharpening enabled toggled") { preferences ->
+            preferences.copy(isVideoSharpeningFilterEnabled = !preferences.isVideoSharpeningFilterEnabled)
+        }
+    }
+
+    private fun updateVideoBrightness(value: Float) {
+        val normalizedValue = value.coerceIn(PlayerPreferences.MIN_VIDEO_BRIGHTNESS, PlayerPreferences.MAX_VIDEO_BRIGHTNESS).round(2)
+        updateVideoFilter("brightness=$normalizedValue") { it.copy(videoBrightness = normalizedValue) }
+    }
+
+    private fun updateVideoContrast(value: Float) {
+        val normalizedValue = value.coerceIn(PlayerPreferences.MIN_VIDEO_CONTRAST, PlayerPreferences.MAX_VIDEO_CONTRAST).round(2)
+        updateVideoFilter("contrast=$normalizedValue") { it.copy(videoContrast = normalizedValue) }
+    }
+
+    private fun updateVideoSaturation(value: Float) {
+        val normalizedValue = value.coerceIn(PlayerPreferences.MIN_VIDEO_SATURATION, PlayerPreferences.MAX_VIDEO_SATURATION).round(0)
+        updateVideoFilter("saturation=$normalizedValue") { it.copy(videoSaturation = normalizedValue) }
+    }
+
+    private fun updateVideoHue(value: Float) {
+        val normalizedValue = value.coerceIn(PlayerPreferences.MIN_VIDEO_HUE, PlayerPreferences.MAX_VIDEO_HUE).round(0)
+        updateVideoFilter("hue=$normalizedValue") { it.copy(videoHue = normalizedValue) }
+    }
+
+    private fun updateVideoGamma(value: Float) {
+        val normalizedValue = value.coerceIn(PlayerPreferences.MIN_VIDEO_GAMMA, PlayerPreferences.MAX_VIDEO_GAMMA).round(2)
+        updateVideoFilter("gamma=$normalizedValue") { it.copy(videoGamma = normalizedValue) }
+    }
+
+    private fun updateVideoSharpening(value: Float) {
+        val normalizedValue = value.coerceIn(PlayerPreferences.DEFAULT_VIDEO_SHARPENING, PlayerPreferences.MAX_VIDEO_SHARPENING).round(2)
+        updateVideoFilter("sharpening=$normalizedValue") { it.copy(videoSharpening = normalizedValue) }
+    }
+
+    private fun updateVideoFilter(
+        debugValue: String,
+        transform: (PlayerPreferences) -> PlayerPreferences,
+    ) {
+        Logger.debug(TAG, "Update video filter from settings: $debugValue")
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences(transform)
+        }
+    }
+}
+
+@Stable
+data class DecoderPreferencesUiState(
+    val showDialog: DecoderPreferenceDialog? = null,
+    val preferences: PlayerPreferences = PlayerPreferences(),
+)
+
+sealed interface DecoderPreferenceDialog {
+    data object DecoderPriorityDialog : DecoderPreferenceDialog
+}
+
+sealed interface DecoderPreferencesUiEvent {
+    data class ShowDialog(val value: DecoderPreferenceDialog?) : DecoderPreferencesUiEvent
+    data class UpdateDecoderPriority(val value: DecoderPriority) : DecoderPreferencesUiEvent
+    data object ToggleVideoFilters : DecoderPreferencesUiEvent
+    data object ToggleVideoBrightnessFilter : DecoderPreferencesUiEvent
+    data class UpdateVideoBrightness(val value: Float) : DecoderPreferencesUiEvent
+    data object ToggleVideoContrastFilter : DecoderPreferencesUiEvent
+    data class UpdateVideoContrast(val value: Float) : DecoderPreferencesUiEvent
+    data object ToggleVideoSaturationFilter : DecoderPreferencesUiEvent
+    data class UpdateVideoSaturation(val value: Float) : DecoderPreferencesUiEvent
+    data object ToggleVideoHueFilter : DecoderPreferencesUiEvent
+    data class UpdateVideoHue(val value: Float) : DecoderPreferencesUiEvent
+    data object ToggleVideoGammaFilter : DecoderPreferencesUiEvent
+    data class UpdateVideoGamma(val value: Float) : DecoderPreferencesUiEvent
+    data object ToggleVideoSharpeningFilter : DecoderPreferencesUiEvent
+    data class UpdateVideoSharpening(val value: Float) : DecoderPreferencesUiEvent
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/general/GeneralPreferencesScreen.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/general/GeneralPreferencesScreen.kt
new file mode 100644
index 000000000..9f3f7e5fd
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/general/GeneralPreferencesScreen.kt
@@ -0,0 +1,211 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.general
+
+import android.widget.Toast
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts.CreateDocument
+import androidx.activity.result.contract.ActivityResultContracts.OpenDocument
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.CancelButton
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ClickablePreferenceItem
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ListSectionTitle
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextDialog
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextTopAppBar
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.withBottomFallback
+import app.gyrolet.mpvrx.presentation.Screen
+import app.gyrolet.mpvrx.ui.icons.Icon
+import app.gyrolet.mpvrx.ui.utils.LocalBackStack
+import app.gyrolet.mpvrx.ui.utils.popSafely
+import kotlinx.serialization.Serializable
+import org.koin.compose.viewmodel.koinViewModel
+
+@Serializable
+object ExoGeneralPreferencesScreen : Screen {
+    @Composable
+    override fun Content() {
+        val backstack = LocalBackStack.current
+        GeneralPreferencesScreen(
+            onNavigateUp = { backstack.popSafely() }
+        )
+    }
+}
+
+@Composable
+fun GeneralPreferencesScreen(
+    onNavigateUp: () -> Unit,
+    viewModel: GeneralPreferencesViewModel = koinViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    GeneralPreferencesContent(
+        uiState = uiState,
+        onEvent = viewModel::onEvent,
+        onNavigateUp = onNavigateUp,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun GeneralPreferencesContent(
+    uiState: GeneralPreferencesUiState,
+    onEvent: (GeneralPreferencesUiEvent) -> Unit,
+    onNavigateUp: () -> Unit,
+) {
+    val context = LocalContext.current
+    val createBackupLauncher = rememberLauncherForActivityResult(
+        contract = CreateDocument("application/json"),
+    ) { uri ->
+        onEvent(GeneralPreferencesUiEvent.OnBackupFileSelected(context, uri))
+    }
+    val restoreBackupLauncher = rememberLauncherForActivityResult(
+        contract = OpenDocument(),
+    ) { uri ->
+        onEvent(GeneralPreferencesUiEvent.OnRestoreFileSelected(context, uri))
+    }
+
+    LaunchedEffect(uiState.pendingAction) {
+        when (uiState.pendingAction) {
+            GeneralPreferencesPendingAction.BackupSettings -> {
+                // TODO: Use a standard backup file name string if available
+                createBackupLauncher.launch("exoplayer-settings.json")
+            }
+            GeneralPreferencesPendingAction.RestoreSettings -> {
+                restoreBackupLauncher.launch(arrayOf("application/json"))
+            }
+            null -> Unit
+        }
+    }
+
+    val backupSuccessMsg = stringResource(R.string.backup_settings_success)
+    val backupFailedMsg = stringResource(R.string.backup_settings_failed)
+    val restoreSuccessMsg = stringResource(R.string.restore_settings_success)
+    val restoreFailedMsg = stringResource(R.string.restore_settings_failed)
+
+    LaunchedEffect(uiState.resultMessage) {
+        val message = when (uiState.resultMessage) {
+            GeneralPreferencesResultMessage.BackupSucceeded -> backupSuccessMsg
+            GeneralPreferencesResultMessage.BackupFailed -> backupFailedMsg
+            GeneralPreferencesResultMessage.RestoreSucceeded -> restoreSuccessMsg
+            GeneralPreferencesResultMessage.RestoreFailed -> restoreFailedMsg
+            null -> null
+        } ?: return@LaunchedEffect
+
+        Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
+        onEvent(GeneralPreferencesUiEvent.ClearResultMessage)
+    }
+
+    Scaffold(
+        topBar = {
+            NextTopAppBar(
+                title = stringResource(id = R.string.exo_general_name),
+                navigationIcon = {
+                    FilledTonalIconButton(onClick = onNavigateUp) {
+                        Icon(
+                            imageVector = NextIcons.ArrowBack,
+                            contentDescription = stringResource(id = R.string.generic_cancel),
+                        )
+                    }
+                },
+            )
+        },
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .verticalScroll(state = rememberScrollState())
+                .padding(innerPadding.withBottomFallback())
+                .padding(horizontal = 16.dp),
+        ) {
+            ListSectionTitle(text = stringResource(id = R.string.user_data))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_general_backup_settings"),
+                    title = stringResource(R.string.backup_settings),
+                    description = stringResource(R.string.backup_settings_description),
+                    icon = NextIcons.FileOpen,
+                    onClick = { onEvent(GeneralPreferencesUiEvent.BackupSettings) },
+                    isFirstItem = true,
+                )
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_general_restore_settings"),
+                    title = stringResource(R.string.restore_settings),
+                    description = stringResource(R.string.restore_settings_description),
+                    icon = NextIcons.History,
+                    onClick = { onEvent(GeneralPreferencesUiEvent.RestoreSettings) },
+                )
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_general_reset_settings"),
+                    title = stringResource(R.string.reset_settings),
+                    description = stringResource(R.string.reset_settings_description),
+                    icon = NextIcons.Delete,
+                    onClick = { onEvent(GeneralPreferencesUiEvent.ShowDialog(GeneralPreferencesDialog.ResetSettingsDialog)) },
+                    isLastItem = true,
+                )
+            }
+        }
+
+        uiState.showDialog?.let { dialog ->
+            when (dialog) {
+                GeneralPreferencesDialog.ClearVideoCacheDialog -> {
+                    // Not implemented in this version
+                }
+                GeneralPreferencesDialog.ResetSettingsDialog -> {
+                    NextDialog(
+                        onDismissRequest = { onEvent(GeneralPreferencesUiEvent.ShowDialog(null)) },
+                        title = {
+                            Text(
+                                text = stringResource(R.string.reset_settings),
+                                modifier = Modifier.fillMaxWidth(),
+                            )
+                        },
+                        confirmButton = {
+                            TextButton(
+                                modifier = Modifier.testTag("btn_confirm_settings_general_reset_settings"),
+                                onClick = {
+                                    onEvent(GeneralPreferencesUiEvent.ResetSettings)
+                                    onEvent(GeneralPreferencesUiEvent.ShowDialog(null))
+                                },
+                            ) {
+                                Text(text = stringResource(R.string.generic_reset))
+                            }
+                        },
+                        dismissButton = { CancelButton(onClick = { onEvent(GeneralPreferencesUiEvent.ShowDialog(null)) }) },
+                        content = {
+                            Text(
+                                text = stringResource(R.string.reset_settings_confirmation),
+                                style = MaterialTheme.typography.titleSmall,
+                            )
+                        },
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/general/GeneralPreferencesViewModel.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/general/GeneralPreferencesViewModel.kt
new file mode 100644
index 000000000..d8d8de8fb
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/general/GeneralPreferencesViewModel.kt
@@ -0,0 +1,122 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.general
+
+import android.content.Context
+import android.net.Uri
+import androidx.compose.runtime.Stable
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.common.AppLanguageManager
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.model.SettingsBackup
+
+class GeneralPreferencesViewModel(
+    private val preferencesRepository: PreferencesRepository,
+) : ViewModel() {
+
+    companion object {
+        private const val TAG = "GeneralPreferencesViewModel"
+    }
+
+    private val uiStateInternal = MutableStateFlow(GeneralPreferencesUiState())
+    val uiState = uiStateInternal.asStateFlow()
+
+    fun onEvent(event: GeneralPreferencesUiEvent) {
+        when (event) {
+            is GeneralPreferencesUiEvent.ShowDialog -> showDialog(event.value)
+            GeneralPreferencesUiEvent.ClearVideoCache -> clearVideoCache()
+            GeneralPreferencesUiEvent.ResetSettings -> resetSettings()
+            GeneralPreferencesUiEvent.BackupSettings -> backupSettings()
+            GeneralPreferencesUiEvent.RestoreSettings -> restoreSettings()
+            GeneralPreferencesUiEvent.ClearResultMessage -> clearResultMessage()
+            is GeneralPreferencesUiEvent.OnBackupFileSelected -> onBackupFileSelected(event.context, event.uri)
+            is GeneralPreferencesUiEvent.OnRestoreFileSelected -> onRestoreFileSelected(event.context, event.uri)
+        }
+    }
+
+    private fun showDialog(value: GeneralPreferencesDialog?) {
+        uiStateInternal.update { it.copy(showDialog = value) }
+    }
+
+    private fun clearVideoCache() {
+        // TODO: Implement clear video cache in MpvRx context
+    }
+
+    private fun backupSettings() {
+        uiStateInternal.update { it.copy(pendingAction = GeneralPreferencesPendingAction.BackupSettings) }
+    }
+
+    private fun restoreSettings() {
+        uiStateInternal.update { it.copy(pendingAction = GeneralPreferencesPendingAction.RestoreSettings) }
+    }
+
+    private fun onBackupFileSelected(context: Context, uri: Uri?) {
+        uiStateInternal.update { it.copy(pendingAction = null) }
+        if (uri == null) return
+
+        viewModelScope.launch {
+            // TODO: Implement backup logic using Json if needed
+            uiStateInternal.update { it.copy(resultMessage = GeneralPreferencesResultMessage.BackupFailed) }
+        }
+    }
+
+    private fun onRestoreFileSelected(context: Context, uri: Uri?) {
+        uiStateInternal.update { it.copy(pendingAction = null) }
+        if (uri == null) return
+
+        viewModelScope.launch {
+            // TODO: Implement restore logic
+            uiStateInternal.update { it.copy(resultMessage = GeneralPreferencesResultMessage.RestoreFailed) }
+        }
+    }
+
+    private fun clearResultMessage() {
+        uiStateInternal.update { it.copy(resultMessage = null) }
+    }
+
+    private fun resetSettings() {
+        viewModelScope.launch {
+            preferencesRepository.resetPreferences()
+            AppLanguageManager.applyToCurrent("")
+        }
+    }
+}
+
+@Stable
+data class GeneralPreferencesUiState(
+    val showDialog: GeneralPreferencesDialog? = null,
+    val pendingAction: GeneralPreferencesPendingAction? = null,
+    val resultMessage: GeneralPreferencesResultMessage? = null,
+)
+
+sealed interface GeneralPreferencesPendingAction {
+    data object BackupSettings : GeneralPreferencesPendingAction
+    data object RestoreSettings : GeneralPreferencesPendingAction
+}
+
+sealed interface GeneralPreferencesResultMessage {
+    data object BackupSucceeded : GeneralPreferencesResultMessage
+    data object BackupFailed : GeneralPreferencesResultMessage
+    data object RestoreSucceeded : GeneralPreferencesResultMessage
+    data object RestoreFailed : GeneralPreferencesResultMessage
+}
+
+sealed interface GeneralPreferencesDialog {
+    data object ClearVideoCacheDialog : GeneralPreferencesDialog
+    data object ResetSettingsDialog : GeneralPreferencesDialog
+}
+
+sealed interface GeneralPreferencesUiEvent {
+    data class ShowDialog(val value: GeneralPreferencesDialog?) : GeneralPreferencesUiEvent
+    data class OnBackupFileSelected(val context: Context, val uri: Uri?) : GeneralPreferencesUiEvent
+    data class OnRestoreFileSelected(val context: Context, val uri: Uri?) : GeneralPreferencesUiEvent
+    data object ClearVideoCache : GeneralPreferencesUiEvent
+    data object ResetSettings : GeneralPreferencesUiEvent
+    data object BackupSettings : GeneralPreferencesUiEvent
+    data object RestoreSettings : GeneralPreferencesUiEvent
+    data object ClearResultMessage : GeneralPreferencesUiEvent
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/gesture/GesturePreferencesScreen.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/gesture/GesturePreferencesScreen.kt
new file mode 100644
index 000000000..101052bd0
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/gesture/GesturePreferencesScreen.kt
@@ -0,0 +1,363 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.gesture
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledIconButton
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.round
+import app.gyrolet.mpvrx.exoplayer.core.model.DoubleTapGesture
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ListSectionTitle
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextDialogWithDoneAndCancelButtons
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextTopAppBar
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.OptionsDialog
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSlider
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSwitch
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSwitchWithDivider
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.RadioTextButton
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.withBottomFallback
+import app.gyrolet.mpvrx.exoplayer.settings.extensions.name
+import app.gyrolet.mpvrx.presentation.Screen
+import app.gyrolet.mpvrx.ui.icons.Icon
+import app.gyrolet.mpvrx.ui.utils.LocalBackStack
+import app.gyrolet.mpvrx.ui.utils.popSafely
+import kotlinx.serialization.Serializable
+import org.koin.compose.viewmodel.koinViewModel
+
+@Serializable
+object ExoGesturePreferencesScreen : Screen {
+    @Composable
+    override fun Content() {
+        val backstack = LocalBackStack.current
+        GesturePreferencesScreen(
+            onNavigateUp = { backstack.popSafely() }
+        )
+    }
+}
+
+@Composable
+fun GesturePreferencesScreen(
+    onNavigateUp: () -> Unit,
+    viewModel: GesturePreferencesViewModel = koinViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    GesturePreferencesContent(
+        uiState = uiState,
+        onEvent = viewModel::onEvent,
+        onNavigateUp = onNavigateUp,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun GesturePreferencesContent(
+    uiState: GesturePreferencesUiState,
+    onEvent: (GesturePreferencesUiEvent) -> Unit,
+    onNavigateUp: () -> Unit = {},
+) {
+    Scaffold(
+        topBar = {
+            NextTopAppBar(
+                title = stringResource(id = R.string.exo_gestures),
+                navigationIcon = {
+                    FilledTonalIconButton(onClick = onNavigateUp) {
+                        Icon(
+                            imageVector = NextIcons.ArrowBack,
+                            contentDescription = stringResource(id = R.string.generic_cancel),
+                        )
+                    }
+                },
+            )
+        },
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .verticalScroll(state = rememberScrollState())
+                .padding(innerPadding.withBottomFallback())
+                .padding(horizontal = 16.dp),
+        ) {
+            ListSectionTitle(text = stringResource(id = R.string.swipe_gestures))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_gesture_seek"),
+                    title = stringResource(id = R.string.seek_gesture),
+                    description = stringResource(id = R.string.seek_gesture_description),
+                    icon = NextIcons.SwipeHorizontal,
+                    isChecked = uiState.preferences.shouldUseSeekControls,
+                    onClick = { onEvent(GesturePreferencesUiEvent.ToggleUseSeekControls) },
+                    isFirstItem = true,
+                )
+                PreferenceSlider(
+                    modifier = Modifier.testTag("item_settings_gesture_seek_sensitivity"),
+                    sliderModifier = Modifier.testTag("slider_settings_gesture_seek_sensitivity"),
+                    title = stringResource(R.string.seek_gesture_sensitivity),
+                    description = String.format("%.2f", uiState.preferences.seekSensitivity),
+                    icon = NextIcons.Sensitivity,
+                    isEnabled = uiState.preferences.shouldUseSeekControls,
+                    value = uiState.preferences.seekSensitivity,
+                    valueRange = 0.1f..2.0f,
+                    onValueChange = { onEvent(GesturePreferencesUiEvent.UpdateSeekSensitivity(it)) },
+                    trailingContent = {
+                        FilledIconButton(
+                            modifier = Modifier.testTag("btn_reset_settings_gesture_seek_sensitivity"),
+                            enabled = uiState.preferences.shouldUseSeekControls,
+                            onClick = { onEvent(GesturePreferencesUiEvent.UpdateSeekSensitivity(PlayerPreferences.DEFAULT_SEEK_SENSITIVITY)) },
+                        ) {
+                            Icon(
+                                imageVector = NextIcons.History,
+                                contentDescription = stringResource(id = R.string.generic_reset),
+                            )
+                        }
+                    },
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_gesture_brightness"),
+                    title = stringResource(id = R.string.brightness_gesture),
+                    description = stringResource(id = R.string.brightness_gesture_description),
+                    icon = NextIcons.SwipeVertical,
+                    isChecked = uiState.preferences.isBrightnessSwipeGestureEnabled,
+                    onClick = { onEvent(GesturePreferencesUiEvent.ToggleEnableBrightnessSwipeGesture) },
+                )
+                PreferenceSlider(
+                    modifier = Modifier.testTag("item_settings_gesture_brightness_sensitivity"),
+                    sliderModifier = Modifier.testTag("slider_settings_gesture_brightness_sensitivity"),
+                    title = stringResource(R.string.brightness_gesture_sensitivity),
+                    description = String.format("%.2f", uiState.preferences.brightnessGestureSensitivity),
+                    icon = NextIcons.Sensitivity,
+                    isEnabled = uiState.preferences.isBrightnessSwipeGestureEnabled,
+                    value = uiState.preferences.brightnessGestureSensitivity,
+                    valueRange = 0.1f..2.0f,
+                    onValueChange = { onEvent(GesturePreferencesUiEvent.UpdateBrightnessGestureSensitivity(it)) },
+                    trailingContent = {
+                        FilledIconButton(
+                            modifier = Modifier.testTag("btn_reset_settings_gesture_brightness_sensitivity"),
+                            enabled = uiState.preferences.isBrightnessSwipeGestureEnabled,
+                            onClick = { onEvent(GesturePreferencesUiEvent.UpdateBrightnessGestureSensitivity(PlayerPreferences.DEFAULT_BRIGHTNESS_GESTURE_SENSITIVITY)) },
+                        ) {
+                            Icon(
+                                imageVector = NextIcons.History,
+                                contentDescription = stringResource(id = R.string.generic_reset),
+                            )
+                        }
+                    },
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_gesture_volume"),
+                    title = stringResource(id = R.string.volume_gesture),
+                    description = stringResource(id = R.string.volume_gesture_description),
+                    icon = NextIcons.SwipeVertical,
+                    isChecked = uiState.preferences.isVolumeSwipeGestureEnabled,
+                    onClick = { onEvent(GesturePreferencesUiEvent.ToggleEnableVolumeSwipeGesture) },
+                )
+                PreferenceSlider(
+                    modifier = Modifier.testTag("item_settings_gesture_volume_sensitivity"),
+                    sliderModifier = Modifier.testTag("slider_settings_gesture_volume_sensitivity"),
+                    title = stringResource(R.string.volume_gesture_sensitivity),
+                    description = String.format("%.2f", uiState.preferences.volumeGestureSensitivity),
+                    icon = NextIcons.Sensitivity,
+                    isEnabled = uiState.preferences.isVolumeSwipeGestureEnabled,
+                    value = uiState.preferences.volumeGestureSensitivity,
+                    valueRange = 0.1f..2.0f,
+                    onValueChange = { onEvent(GesturePreferencesUiEvent.UpdateVolumeGestureSensitivity(it)) },
+                    isLastItem = true,
+                    trailingContent = {
+                        FilledIconButton(
+                            modifier = Modifier.testTag("btn_reset_settings_gesture_volume_sensitivity"),
+                            enabled = uiState.preferences.isVolumeSwipeGestureEnabled,
+                            onClick = { onEvent(GesturePreferencesUiEvent.UpdateVolumeGestureSensitivity(PlayerPreferences.DEFAULT_VOLUME_GESTURE_SENSITIVITY)) },
+                        ) {
+                            Icon(
+                                imageVector = NextIcons.History,
+                                contentDescription = stringResource(id = R.string.generic_reset),
+                            )
+                        }
+                    },
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.tap_gestures))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitchWithDivider(
+                    modifier = Modifier.testTag("item_settings_gesture_double_tap"),
+                    switchModifier = Modifier.testTag("switch_settings_gesture_double_tap"),
+                    title = stringResource(id = R.string.double_tap),
+                    description = stringResource(id = R.string.double_tap_description),
+                    icon = NextIcons.DoubleTap,
+                    isChecked = (uiState.preferences.doubleTapGesture != DoubleTapGesture.NONE),
+                    onChecked = { onEvent(GesturePreferencesUiEvent.ToggleDoubleTapGesture) },
+                    onClick = { onEvent(GesturePreferencesUiEvent.ShowDialog(GesturePreferenceDialog.DoubleTapDialog)) },
+                    isFirstItem = true,
+                    isLastItem = true,
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.long_press_gestures))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitchWithDivider(
+                    modifier = Modifier.testTag("item_settings_gesture_long_press"),
+                    switchModifier = Modifier.testTag("switch_settings_gesture_long_press"),
+                    title = stringResource(id = R.string.long_press_gesture),
+                    description = stringResource(id = R.string.long_press_gesture_desc, uiState.preferences.longPressControlsSpeed),
+                    icon = NextIcons.Tap,
+                    isChecked = uiState.preferences.shouldUseLongPressControls,
+                    onChecked = { onEvent(GesturePreferencesUiEvent.ToggleUseLongPressControls) },
+                    onClick = { onEvent(GesturePreferencesUiEvent.ShowDialog(GesturePreferenceDialog.LongPressControlsSpeedDialog)) },
+                    isFirstItem = true,
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_gesture_long_press_variable_speed"),
+                    title = stringResource(id = R.string.long_press_variable_speed),
+                    description = stringResource(id = R.string.long_press_variable_speed_desc),
+                    icon = NextIcons.SwipeHorizontal,
+                    isEnabled = uiState.preferences.shouldUseLongPressControls,
+                    isChecked = uiState.preferences.shouldUseLongPressVariableSpeed,
+                    onClick = { onEvent(GesturePreferencesUiEvent.ToggleUseLongPressVariableSpeed) },
+                    isLastItem = true,
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.zoom_and_pan_gestures))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_gesture_zoom"),
+                    title = stringResource(id = R.string.zoom_gesture),
+                    description = stringResource(id = R.string.zoom_gesture_description),
+                    icon = NextIcons.Pinch,
+                    isChecked = uiState.preferences.shouldUseZoomControls,
+                    onClick = { onEvent(GesturePreferencesUiEvent.ToggleUseZoomControls) },
+                    isFirstItem = true,
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_gesture_pan"),
+                    title = stringResource(id = R.string.pan_gesture),
+                    description = stringResource(id = R.string.pan_gesture_description),
+                    icon = NextIcons.Pan,
+                    isEnabled = uiState.preferences.shouldUseZoomControls,
+                    isChecked = uiState.preferences.isPanGestureEnabled,
+                    onClick = { onEvent(GesturePreferencesUiEvent.ToggleEnablePanGesture) },
+                    isLastItem = true,
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.other_gestures))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSlider(
+                    modifier = Modifier.testTag("item_settings_gesture_seek_increment"),
+                    sliderModifier = Modifier.testTag("slider_settings_gesture_seek_increment"),
+                    title = stringResource(R.string.seek_increment),
+                    description = stringResource(R.string.exo_seconds, uiState.preferences.seekIncrement),
+                    icon = NextIcons.Replay,
+                    value = uiState.preferences.seekIncrement.toFloat(),
+                    valueRange = 1.0f..PlayerPreferences.MAX_SEEK_INCREMENT.toFloat(),
+                    onValueChange = { onEvent(GesturePreferencesUiEvent.UpdateSeekIncrement(it.toInt())) },
+                    isFirstItem = true,
+                    isLastItem = true,
+                    trailingContent = {
+                        FilledIconButton(
+                            modifier = Modifier.testTag("btn_reset_settings_gesture_seek_increment"),
+                            onClick = { onEvent(GesturePreferencesUiEvent.UpdateSeekIncrement(PlayerPreferences.DEFAULT_SEEK_INCREMENT)) },
+                        ) {
+                            Icon(
+                                imageVector = NextIcons.History,
+                                contentDescription = stringResource(id = R.string.generic_reset),
+                            )
+                        }
+                    },
+                )
+            }
+        }
+
+        uiState.showDialog?.let { showDialog ->
+            when (showDialog) {
+                GesturePreferenceDialog.DoubleTapDialog -> {
+                    OptionsDialog(
+                        title = stringResource(id = R.string.double_tap),
+                        onDismissClick = { onEvent(GesturePreferencesUiEvent.ShowDialog(null)) },
+                    ) {
+                        items(DoubleTapGesture.entries.toTypedArray()) {
+                            RadioTextButton(
+                                modifier = Modifier.testTag("option_settings_gesture_double_tap_${it.name.lowercase()}"),
+                                text = it.name(),
+                                isSelected = (it == uiState.preferences.doubleTapGesture),
+                                onClick = {
+                                    onEvent(GesturePreferencesUiEvent.UpdateDoubleTapGesture(it))
+                                    onEvent(GesturePreferencesUiEvent.ShowDialog(null))
+                                },
+                            )
+                        }
+                    }
+                }
+
+                GesturePreferenceDialog.LongPressControlsSpeedDialog -> {
+                    var longPressControlsSpeed by remember {
+                        mutableFloatStateOf(uiState.preferences.longPressControlsSpeed)
+                    }
+
+                    NextDialogWithDoneAndCancelButtons(
+                        title = stringResource(R.string.long_press_gesture),
+                        onDoneClick = {
+                            onEvent(GesturePreferencesUiEvent.UpdateLongPressControlsSpeed(longPressControlsSpeed))
+                            onEvent(GesturePreferencesUiEvent.ShowDialog(null))
+                        },
+                        onDismissClick = { onEvent(GesturePreferencesUiEvent.ShowDialog(null)) },
+                        content = {
+                            Text(
+                                text = "$longPressControlsSpeed",
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .padding(vertical = 20.dp),
+                                textAlign = TextAlign.Center,
+                                style = MaterialTheme.typography.titleMedium,
+                            )
+                            Slider(
+                                modifier = Modifier.testTag("slider_settings_gesture_long_press_speed"),
+                                value = longPressControlsSpeed,
+                                onValueChange = { longPressControlsSpeed = it.round(1) },
+                                valueRange = PlayerPreferences.MIN_LONG_PRESS_CONTROLS_SPEED..PlayerPreferences.MAX_LONG_PRESS_CONTROLS_SPEED,
+                            )
+                        },
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/gesture/GesturePreferencesViewModel.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/gesture/GesturePreferencesViewModel.kt
new file mode 100644
index 000000000..10c8bb592
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/gesture/GesturePreferencesViewModel.kt
@@ -0,0 +1,211 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.gesture
+
+import androidx.compose.runtime.Stable
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.round
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.model.DoubleTapGesture
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+
+class GesturePreferencesViewModel(
+    private val preferencesRepository: PreferencesRepository,
+) : ViewModel() {
+
+    private val uiStateInternal = MutableStateFlow(
+        GesturePreferencesUiState(
+            preferences = preferencesRepository.playerPreferences.value,
+        ),
+    )
+    val uiState = uiStateInternal.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            preferencesRepository.playerPreferences.collect { preferences ->
+                uiStateInternal.update { it.copy(preferences = preferences) }
+            }
+        }
+    }
+
+    fun onEvent(event: GesturePreferencesUiEvent) {
+        when (event) {
+            is GesturePreferencesUiEvent.ShowDialog -> showDialog(event.value)
+            is GesturePreferencesUiEvent.UpdateDoubleTapGesture -> updateDoubleTapGesture(event.gesture)
+            GesturePreferencesUiEvent.ToggleUseLongPressControls -> toggleUseLongPressControls()
+            GesturePreferencesUiEvent.ToggleUseLongPressVariableSpeed -> toggleUseLongPressVariableSpeed()
+            GesturePreferencesUiEvent.ToggleDoubleTapGesture -> toggleDoubleTapGesture()
+            GesturePreferencesUiEvent.ToggleEnableBrightnessSwipeGesture -> toggleEnableBrightnessSwipeGesture()
+            GesturePreferencesUiEvent.ToggleEnableVolumeSwipeGesture -> toggleEnableVolumeSwipeGesture()
+            GesturePreferencesUiEvent.ToggleUseSeekControls -> toggleUseSeekControls()
+            GesturePreferencesUiEvent.ToggleUseZoomControls -> toggleUseZoomControls()
+            GesturePreferencesUiEvent.ToggleEnablePanGesture -> toggleEnablePanGesture()
+            is GesturePreferencesUiEvent.UpdateLongPressControlsSpeed -> updateLongPressControlsSpeed(event.value)
+            is GesturePreferencesUiEvent.UpdateSeekIncrement -> updateSeekIncrement(event.value)
+            is GesturePreferencesUiEvent.UpdateSeekSensitivity -> updateSeekSensitivity(event.value)
+            is GesturePreferencesUiEvent.UpdateVolumeGestureSensitivity -> updateVolumeGestureSensitivity(event.value)
+            is GesturePreferencesUiEvent.UpdateBrightnessGestureSensitivity -> updateBrightnessGestureSensitivity(event.value)
+        }
+    }
+
+    private fun showDialog(value: GesturePreferenceDialog?) {
+        uiStateInternal.update {
+            it.copy(showDialog = value)
+        }
+    }
+
+    private fun updateDoubleTapGesture(gesture: DoubleTapGesture) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(doubleTapGesture = gesture)
+            }
+        }
+    }
+
+    private fun toggleUseLongPressControls() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                val shouldUseLongPressControls = !it.shouldUseLongPressControls
+                it.copy(
+                    shouldUseLongPressControls = shouldUseLongPressControls,
+                    shouldUseLongPressVariableSpeed = it.shouldUseLongPressVariableSpeed && shouldUseLongPressControls,
+                )
+            }
+        }
+    }
+
+    private fun toggleUseLongPressVariableSpeed() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                if (!it.shouldUseLongPressControls) {
+                    return@updatePlayerPreferences it.copy(shouldUseLongPressVariableSpeed = false)
+                }
+                it.copy(shouldUseLongPressVariableSpeed = !it.shouldUseLongPressVariableSpeed)
+            }
+        }
+    }
+
+    private fun toggleDoubleTapGesture() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(
+                    doubleTapGesture = if (it.doubleTapGesture == DoubleTapGesture.NONE) {
+                        DoubleTapGesture.FAST_FORWARD_AND_REWIND
+                    } else {
+                        DoubleTapGesture.NONE
+                    },
+                )
+            }
+        }
+    }
+
+    private fun toggleEnableBrightnessSwipeGesture() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(isBrightnessSwipeGestureEnabled = !it.isBrightnessSwipeGestureEnabled)
+            }
+        }
+    }
+
+    private fun toggleEnableVolumeSwipeGesture() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(isVolumeSwipeGestureEnabled = !it.isVolumeSwipeGestureEnabled)
+            }
+        }
+    }
+
+    private fun toggleUseSeekControls() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldUseSeekControls = !it.shouldUseSeekControls)
+            }
+        }
+    }
+
+    private fun toggleUseZoomControls() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldUseZoomControls = !it.shouldUseZoomControls)
+            }
+        }
+    }
+
+    private fun toggleEnablePanGesture() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(isPanGestureEnabled = !it.isPanGestureEnabled)
+            }
+        }
+    }
+
+    private fun updateLongPressControlsSpeed(value: Float) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences { it.copy(longPressControlsSpeed = value) }
+        }
+    }
+
+    private fun updateSeekIncrement(value: Int) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(seekIncrement = value.coerceIn(1, PlayerPreferences.MAX_SEEK_INCREMENT))
+            }
+        }
+    }
+
+    private fun updateSeekSensitivity(value: Float) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(seekSensitivity = value.round(2))
+            }
+        }
+    }
+
+    private fun updateVolumeGestureSensitivity(value: Float) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(volumeGestureSensitivity = value.round(2))
+            }
+        }
+    }
+
+    private fun updateBrightnessGestureSensitivity(value: Float) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(brightnessGestureSensitivity = value.round(2))
+            }
+        }
+    }
+}
+
+@Stable
+data class GesturePreferencesUiState(
+    val showDialog: GesturePreferenceDialog? = null,
+    val preferences: PlayerPreferences = PlayerPreferences(),
+)
+
+sealed interface GesturePreferenceDialog {
+    data object DoubleTapDialog : GesturePreferenceDialog
+    data object LongPressControlsSpeedDialog : GesturePreferenceDialog
+}
+
+sealed interface GesturePreferencesUiEvent {
+    data class ShowDialog(val value: GesturePreferenceDialog?) : GesturePreferencesUiEvent
+    data class UpdateDoubleTapGesture(val gesture: DoubleTapGesture) : GesturePreferencesUiEvent
+    data object ToggleUseLongPressControls : GesturePreferencesUiEvent
+    data object ToggleUseLongPressVariableSpeed : GesturePreferencesUiEvent
+    data object ToggleDoubleTapGesture : GesturePreferencesUiEvent
+    data object ToggleEnableBrightnessSwipeGesture : GesturePreferencesUiEvent
+    data object ToggleEnableVolumeSwipeGesture : GesturePreferencesUiEvent
+    data object ToggleUseSeekControls : GesturePreferencesUiEvent
+    data object ToggleUseZoomControls : GesturePreferencesUiEvent
+    data object ToggleEnablePanGesture : GesturePreferencesUiEvent
+    data class UpdateLongPressControlsSpeed(val value: Float) : GesturePreferencesUiEvent
+    data class UpdateSeekIncrement(val value: Int) : GesturePreferencesUiEvent
+    data class UpdateSeekSensitivity(val value: Float) : GesturePreferencesUiEvent
+    data class UpdateVolumeGestureSensitivity(val value: Float) : GesturePreferencesUiEvent
+    data class UpdateBrightnessGestureSensitivity(val value: Float) : GesturePreferencesUiEvent
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/medialibrary/MediaLibraryPreferencesScreen.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/medialibrary/MediaLibraryPreferencesScreen.kt
new file mode 100644
index 000000000..6e8b0a9fc
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/medialibrary/MediaLibraryPreferencesScreen.kt
@@ -0,0 +1,151 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.medialibrary
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.model.ThumbnailGenerationStrategy
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ClickablePreferenceItem
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ListSectionTitle
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextTopAppBar
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSwitch
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.withBottomFallback
+import app.gyrolet.mpvrx.presentation.Screen
+import app.gyrolet.mpvrx.ui.icons.Icon
+import app.gyrolet.mpvrx.ui.icons.Icons
+import app.gyrolet.mpvrx.ui.utils.LocalBackStack
+import app.gyrolet.mpvrx.ui.utils.popSafely
+import kotlinx.serialization.Serializable
+import org.koin.compose.viewmodel.koinViewModel
+
+@Serializable
+object ExoMediaLibraryPreferencesScreen : Screen {
+
+    @Composable
+    override fun Content() {
+        val backstack = LocalBackStack.current
+        MediaLibraryPreferencesScreen(
+            onNavigateUp = { backstack.popSafely() },
+            onThumbnailSettingClick = {
+                // TODO: Navigate to thumbnail settings if needed
+            }
+        )
+    }
+}
+
+@Composable
+fun MediaLibraryPreferencesScreen(
+    onNavigateUp: () -> Unit,
+    onThumbnailSettingClick: () -> Unit = {},
+    viewModel: MediaLibraryPreferencesViewModel = koinViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    MediaLibraryPreferencesContent(
+        uiState = uiState,
+        onNavigateUp = onNavigateUp,
+        onThumbnailSettingClick = onThumbnailSettingClick,
+        onEvent = viewModel::onEvent,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun MediaLibraryPreferencesContent(
+    uiState: MediaLibraryPreferencesUiState,
+    onNavigateUp: () -> Unit,
+    onThumbnailSettingClick: () -> Unit,
+    onEvent: (MediaLibraryPreferencesUiEvent) -> Unit,
+) {
+    val preferences = uiState.preferences
+
+    Scaffold(
+        topBar = {
+            NextTopAppBar(
+                title = stringResource(id = R.string.exo_media_library),
+                navigationIcon = {
+                    FilledTonalIconButton(onClick = onNavigateUp) {
+                        Icon(
+                            imageVector = NextIcons.ArrowBack,
+                            contentDescription = stringResource(id = R.string.generic_cancel),
+                        )
+                    }
+                },
+            )
+        },
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .verticalScroll(state = rememberScrollState())
+                .padding(innerPadding.withBottomFallback())
+                .padding(horizontal = 16.dp),
+        ) {
+            ListSectionTitle(text = stringResource(id = R.string.exo_media_library))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_media_mark_last_played"),
+                    title = stringResource(id = R.string.mark_last_played_media),
+                    description = stringResource(
+                        id = R.string.mark_last_played_media_desc,
+                    ),
+                    icon = NextIcons.Check,
+                    isChecked = preferences.shouldMarkLastPlayedMedia,
+                    onClick = { onEvent(MediaLibraryPreferencesUiEvent.ToggleMarkLastPlayedMedia) },
+                    isFirstItem = true,
+                    isLastItem = false,
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_media_restore_last_played_in_folders"),
+                    title = stringResource(id = R.string.restore_last_played_media_in_folders),
+                    description = stringResource(id = R.string.restore_last_played_media_in_folders_desc),
+                    icon = NextIcons.History,
+                    isChecked = preferences.shouldRestoreLastPlayedMediaInFolders,
+                    onClick = { onEvent(MediaLibraryPreferencesUiEvent.ToggleRestoreLastPlayedMediaInFolders) },
+                    isFirstItem = false,
+                    isLastItem = true,
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.exo_thumbnail))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_media_thumbnails"),
+                    title = stringResource(id = R.string.exo_thumbnail_generation),
+                    description = when (preferences.thumbnailGenerationStrategy) {
+                        ThumbnailGenerationStrategy.FIRST_FRAME -> stringResource(id = R.string.first_frame)
+                        ThumbnailGenerationStrategy.FRAME_AT_PERCENTAGE -> stringResource(R.string.frame_at_position)
+                        ThumbnailGenerationStrategy.HYBRID -> stringResource(id = R.string.hybrid)
+                    },
+                    icon = NextIcons.Image,
+                    onClick = onThumbnailSettingClick,
+                    isFirstItem = true,
+                    isLastItem = true,
+                )
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/medialibrary/MediaLibraryPreferencesViewModel.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/medialibrary/MediaLibraryPreferencesViewModel.kt
new file mode 100644
index 000000000..0c50b3722
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/medialibrary/MediaLibraryPreferencesViewModel.kt
@@ -0,0 +1,105 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.medialibrary
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.model.ApplicationPreferences
+
+class MediaLibraryPreferencesViewModel(
+    private val preferencesRepository: PreferencesRepository,
+) : ViewModel() {
+
+    private val uiStateInternal = MutableStateFlow(MediaLibraryPreferencesUiState())
+    val uiState: StateFlow<MediaLibraryPreferencesUiState> = uiStateInternal.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            preferencesRepository.applicationPreferences.collect {
+                uiStateInternal.update { currentState ->
+                    currentState.copy(preferences = it)
+                }
+            }
+        }
+    }
+
+    fun onEvent(event: MediaLibraryPreferencesUiEvent) {
+        when (event) {
+            is MediaLibraryPreferencesUiEvent.SetIgnoreNoMediaFiles -> setIgnoreNoMediaFiles(event.shouldIgnoreNoMediaFiles)
+            MediaLibraryPreferencesUiEvent.ResetRestrictedFeatures -> resetRestrictedFeatures()
+            MediaLibraryPreferencesUiEvent.ToggleMarkLastPlayedMedia -> toggleMarkLastPlayedMedia()
+            MediaLibraryPreferencesUiEvent.ToggleRestoreLastPlayedMediaInFolders -> toggleRestoreLastPlayedMediaInFolders()
+            MediaLibraryPreferencesUiEvent.ToggleRecycleBinEnabled -> toggleRecycleBinEnabled()
+        }
+    }
+
+    private fun setIgnoreNoMediaFiles(shouldIgnoreNoMediaFiles: Boolean) {
+        viewModelScope.launch {
+            preferencesRepository.updateApplicationPreferences {
+                if (it.shouldIgnoreNoMediaFiles == shouldIgnoreNoMediaFiles) {
+                    it
+                } else {
+                    it.copy(shouldIgnoreNoMediaFiles = shouldIgnoreNoMediaFiles)
+                }
+            }
+        }
+    }
+
+    private fun toggleMarkLastPlayedMedia() {
+        viewModelScope.launch {
+            preferencesRepository.updateApplicationPreferences {
+                it.copy(shouldMarkLastPlayedMedia = !it.shouldMarkLastPlayedMedia)
+            }
+        }
+    }
+
+    private fun toggleRestoreLastPlayedMediaInFolders() {
+        viewModelScope.launch {
+            preferencesRepository.updateApplicationPreferences {
+                it.copy(shouldRestoreLastPlayedMediaInFolders = !it.shouldRestoreLastPlayedMediaInFolders)
+            }
+        }
+    }
+
+    private fun resetRestrictedFeatures() {
+        viewModelScope.launch {
+            preferencesRepository.updateApplicationPreferences {
+                val shouldResetIgnoreNoMediaFiles = it.shouldIgnoreNoMediaFiles
+                val shouldResetRecycleBin = it.isRecycleBinEnabled
+
+                if (!shouldResetIgnoreNoMediaFiles && !shouldResetRecycleBin) {
+                    it
+                } else {
+                    it.copy(
+                        shouldIgnoreNoMediaFiles = false,
+                        isRecycleBinEnabled = false,
+                    )
+                }
+            }
+        }
+    }
+
+    private fun toggleRecycleBinEnabled() {
+        viewModelScope.launch {
+            preferencesRepository.updateApplicationPreferences {
+                it.copy(isRecycleBinEnabled = !it.isRecycleBinEnabled)
+            }
+        }
+    }
+}
+
+data class MediaLibraryPreferencesUiState(
+    val preferences: ApplicationPreferences = ApplicationPreferences(),
+)
+
+sealed interface MediaLibraryPreferencesUiEvent {
+    data class SetIgnoreNoMediaFiles(val shouldIgnoreNoMediaFiles: Boolean) : MediaLibraryPreferencesUiEvent
+    data object ResetRestrictedFeatures : MediaLibraryPreferencesUiEvent
+    data object ToggleMarkLastPlayedMedia : MediaLibraryPreferencesUiEvent
+    data object ToggleRestoreLastPlayedMediaInFolders : MediaLibraryPreferencesUiEvent
+    data object ToggleRecycleBinEnabled : MediaLibraryPreferencesUiEvent
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/player/PlayerPreferencesScreen.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/player/PlayerPreferencesScreen.kt
new file mode 100644
index 000000000..7a764f747
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/player/PlayerPreferencesScreen.kt
@@ -0,0 +1,355 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.player
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledIconButton
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.isPipFeatureSupported
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.round
+import app.gyrolet.mpvrx.exoplayer.core.model.ControlButtonsPosition
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControlsStyle
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerIconStyle
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.ScreenOrientation
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ClickablePreferenceItem
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ListSectionTitle
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextTopAppBar
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.OptionsDialog
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSlider
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSwitch
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.RadioTextButton
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.withBottomFallback
+import app.gyrolet.mpvrx.exoplayer.settings.extensions.isEnabled
+import app.gyrolet.mpvrx.exoplayer.settings.extensions.name
+import app.gyrolet.mpvrx.presentation.Screen
+import app.gyrolet.mpvrx.ui.icons.Icon
+import app.gyrolet.mpvrx.ui.utils.LocalBackStack
+import app.gyrolet.mpvrx.ui.utils.popSafely
+import kotlinx.serialization.Serializable
+import org.koin.compose.viewmodel.koinViewModel
+
+@Serializable
+object ExoPlayerPreferencesScreen : Screen {
+    @Composable
+    override fun Content() {
+        val backstack = LocalBackStack.current
+        PlayerPreferencesScreen(
+            onNavigateUp = { backstack.popSafely() }
+        )
+    }
+}
+
+@Composable
+fun PlayerPreferencesScreen(
+    onNavigateUp: () -> Unit,
+    viewModel: PlayerPreferencesViewModel = koinViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    PlayerPreferencesContent(
+        uiState = uiState,
+        onEvent = viewModel::onEvent,
+        onNavigateUp = onNavigateUp,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun PlayerPreferencesContent(
+    uiState: PlayerPreferencesUiState,
+    onEvent: (PlayerPreferencesUiEvent) -> Unit,
+    onNavigateUp: () -> Unit = {},
+) {
+    val isPipFeatureSupported = LocalContext.current.isPipFeatureSupported
+
+    Scaffold(
+        topBar = {
+            NextTopAppBar(
+                title = stringResource(id = R.string.exo_player),
+                navigationIcon = {
+                    FilledTonalIconButton(onClick = onNavigateUp) {
+                        Icon(
+                            imageVector = NextIcons.ArrowBack,
+                            contentDescription = stringResource(id = R.string.generic_cancel),
+                        )
+                    }
+                },
+            )
+        },
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .verticalScroll(state = rememberScrollState())
+                .padding(innerPadding.withBottomFallback())
+                .padding(horizontal = 16.dp),
+        ) {
+            ListSectionTitle(text = stringResource(id = R.string.pref_appearance_title))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSlider(
+                    modifier = Modifier.testTag("item_settings_player_controller_timeout"),
+                    sliderModifier = Modifier.testTag("slider_settings_player_controller_timeout"),
+                    title = stringResource(R.string.controller_timeout),
+                    description = stringResource(R.string.exo_seconds, uiState.preferences.controllerAutoHideTimeout),
+                    icon = NextIcons.Timer,
+                    value = uiState.preferences.controllerAutoHideTimeout.toFloat(),
+                    valueRange = 1.0f..60.0f,
+                    onValueChange = { onEvent(PlayerPreferencesUiEvent.UpdateControlAutoHideTimeout(it.toInt())) },
+                    isFirstItem = true,
+                    trailingContent = {
+                        FilledIconButton(
+                            modifier = Modifier.testTag("btn_reset_settings_player_controller_timeout"),
+                            onClick = { onEvent(PlayerPreferencesUiEvent.UpdateControlAutoHideTimeout(PlayerPreferences.DEFAULT_CONTROLLER_AUTO_HIDE_TIMEOUT)) },
+                        ) {
+                            Icon(
+                                imageVector = NextIcons.History,
+                                contentDescription = stringResource(id = R.string.generic_reset),
+                            )
+                        }
+                    },
+                )
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_player_screen_orientation"),
+                    title = stringResource(id = R.string.player_screen_orientation),
+                    description = uiState.preferences.playerScreenOrientation.name(),
+                    icon = NextIcons.Rotation,
+                    onClick = {
+                        onEvent(PlayerPreferencesUiEvent.ShowDialog(PlayerPreferenceDialog.PlayerScreenOrientationDialog))
+                    },
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_player_remember_orientation"),
+                    title = stringResource(id = R.string.remember_player_screen_orientation),
+                    description = stringResource(id = R.string.remember_player_screen_orientation_description),
+                    icon = NextIcons.History,
+                    isChecked = uiState.preferences.shouldRememberPlayerScreenOrientation,
+                    onClick = { onEvent(PlayerPreferencesUiEvent.ToggleRememberPlayerScreenOrientation) },
+                )
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_player_controls_style"),
+                    title = stringResource(id = R.string.player_controls_style),
+                    description = uiState.preferences.controlsStyle.name(),
+                    icon = NextIcons.Player,
+                    onClick = { onEvent(PlayerPreferencesUiEvent.ShowDialog(PlayerPreferenceDialog.ControlsStyleDialog)) },
+                    isLastItem = uiState.preferences.controlsStyle != PlayerControlsStyle.LEGACY,
+                )
+                if (uiState.preferences.controlsStyle == PlayerControlsStyle.LEGACY) {
+                    ClickablePreferenceItem(
+                        modifier = Modifier.testTag("item_settings_player_icon_style"),
+                        title = stringResource(id = R.string.player_icon_style),
+                        description = uiState.preferences.playerIconStyle.name(),
+                        icon = NextIcons.Style,
+                        onClick = { onEvent(PlayerPreferencesUiEvent.ShowDialog(PlayerPreferenceDialog.PlayerIconStyleDialog)) },
+                        isLastItem = true,
+                    )
+                }
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.playback_behavior))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_player_resume"),
+                    title = stringResource(id = R.string.resume),
+                    description = stringResource(id = R.string.resume_description),
+                    icon = NextIcons.Resume,
+                    isChecked = uiState.preferences.resume.isEnabled,
+                    onClick = { onEvent(PlayerPreferencesUiEvent.TogglePlaybackResume) },
+                    isFirstItem = true,
+                )
+                PreferenceSlider(
+                    modifier = Modifier.testTag("item_settings_player_default_speed"),
+                    sliderModifier = Modifier.testTag("slider_settings_player_default_speed"),
+                    title = stringResource(id = R.string.default_playback_speed),
+                    description = uiState.preferences.defaultPlaybackSpeed.toString(),
+                    icon = NextIcons.Speed,
+                    value = uiState.preferences.defaultPlaybackSpeed,
+                    valueRange = 0.2f..4.0f,
+                    onValueChange = { onEvent(PlayerPreferencesUiEvent.UpdateDefaultPlaybackSpeed(it.round(2))) },
+                    trailingContent = {
+                        FilledIconButton(
+                            modifier = Modifier.testTag("btn_reset_settings_player_default_speed"),
+                            onClick = { onEvent(PlayerPreferencesUiEvent.UpdateDefaultPlaybackSpeed(1f)) },
+                        ) {
+                            Icon(
+                                imageVector = NextIcons.History,
+                                contentDescription = stringResource(id = R.string.generic_reset),
+                            )
+                        }
+                    },
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_player_autoplay"),
+                    title = stringResource(id = R.string.autoplay_settings),
+                    description = stringResource(
+                        id = R.string.autoplay_settings_description,
+                    ),
+                    icon = NextIcons.Player,
+                    isChecked = uiState.preferences.shouldAutoPlay,
+                    onClick = { onEvent(PlayerPreferencesUiEvent.ToggleAutoplay) },
+                )
+                if (isPipFeatureSupported) {
+                    PreferenceSwitch(
+                        modifier = Modifier.testTag("switch_settings_player_auto_pip"),
+                        title = stringResource(id = R.string.pip_settings),
+                        description = stringResource(
+                            id = R.string.pip_settings_description,
+                        ),
+                        icon = NextIcons.Pip,
+                        isChecked = uiState.preferences.shouldAutoEnterPip,
+                        onClick = { onEvent(PlayerPreferencesUiEvent.ToggleAutoPip) },
+                    )
+                }
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_player_background_play"),
+                    title = stringResource(id = R.string.background_play),
+                    description = stringResource(
+                        id = R.string.background_play_description,
+                    ),
+                    icon = NextIcons.Headset,
+                    isChecked = uiState.preferences.shouldAutoPlayInBackground,
+                    onClick = { onEvent(PlayerPreferencesUiEvent.ToggleAutoBackgroundPlay) },
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_player_remember_brightness"),
+                    title = stringResource(id = R.string.remember_brightness_level),
+                    description = stringResource(
+                        id = R.string.remember_brightness_level_description,
+                    ),
+                    icon = NextIcons.Brightness,
+                    isChecked = uiState.preferences.shouldRememberPlayerBrightness,
+                    onClick = { onEvent(PlayerPreferencesUiEvent.ToggleRememberBrightnessLevel) },
+                    isLastItem = true,
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.player_controls))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_player_control_buttons_position"),
+                    title = stringResource(id = R.string.control_buttons_alignment),
+                    description = uiState.preferences.controlButtonsPosition.name(),
+                    icon = NextIcons.ButtonsPosition,
+                    onClick = { onEvent(PlayerPreferencesUiEvent.ShowDialog(PlayerPreferenceDialog.ControlButtonsDialog)) },
+                    isFirstItem = true,
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_player_control_labels"),
+                    title = stringResource(id = R.string.player_control_labels),
+                    description = stringResource(id = R.string.player_control_labels_description),
+                    icon = NextIcons.Title,
+                    isChecked = uiState.preferences.shouldHidePlayerControlLabels,
+                    onClick = { onEvent(PlayerPreferencesUiEvent.TogglePlayerControlLabels) },
+                    isLastItem = true,
+                )
+            }
+        }
+
+        uiState.showDialog?.let { showDialog ->
+            when (showDialog) {
+                PlayerPreferenceDialog.PlayerScreenOrientationDialog -> {
+                    OptionsDialog(
+                        title = stringResource(id = R.string.player_screen_orientation),
+                        onDismissClick = { onEvent(PlayerPreferencesUiEvent.ShowDialog(null)) },
+                    ) {
+                        items(ScreenOrientation.entries.toTypedArray()) {
+                            RadioTextButton(
+                                modifier = Modifier.testTag("option_settings_player_screen_orientation_${it.name.lowercase()}"),
+                                text = it.name(),
+                                isSelected = it == uiState.preferences.playerScreenOrientation,
+                                onClick = {
+                                    onEvent(PlayerPreferencesUiEvent.UpdatePreferredPlayerOrientation(it))
+                                    onEvent(PlayerPreferencesUiEvent.ShowDialog(null))
+                                },
+                            )
+                        }
+                    }
+                }
+
+                PlayerPreferenceDialog.ControlButtonsDialog -> {
+                    OptionsDialog(
+                        title = stringResource(id = R.string.control_buttons_alignment),
+                        onDismissClick = { onEvent(PlayerPreferencesUiEvent.ShowDialog(null)) },
+                    ) {
+                        items(ControlButtonsPosition.entries.toTypedArray()) {
+                            RadioTextButton(
+                                modifier = Modifier.testTag("option_settings_player_control_buttons_position_${it.name.lowercase()}"),
+                                text = it.name(),
+                                isSelected = it == uiState.preferences.controlButtonsPosition,
+                                onClick = {
+                                    onEvent(PlayerPreferencesUiEvent.UpdatePreferredControlButtonsPosition(it))
+                                    onEvent(PlayerPreferencesUiEvent.ShowDialog(null))
+                                },
+                            )
+                        }
+                    }
+                }
+
+                PlayerPreferenceDialog.PlayerIconStyleDialog -> {
+                    OptionsDialog(
+                        title = stringResource(id = R.string.player_icon_style),
+                        onDismissClick = { onEvent(PlayerPreferencesUiEvent.ShowDialog(null)) },
+                    ) {
+                        items(PlayerIconStyle.entries.toTypedArray()) {
+                            RadioTextButton(
+                                modifier = Modifier.testTag("option_settings_player_icon_style_${it.name.lowercase()}"),
+                                text = it.name(),
+                                isSelected = it == uiState.preferences.playerIconStyle,
+                                onClick = {
+                                    onEvent(PlayerPreferencesUiEvent.UpdatePlayerIconStyle(it))
+                                    onEvent(PlayerPreferencesUiEvent.ShowDialog(null))
+                                },
+                            )
+                        }
+                    }
+                }
+
+                PlayerPreferenceDialog.ControlsStyleDialog -> {
+                    OptionsDialog(
+                        title = stringResource(id = R.string.player_controls_style),
+                        onDismissClick = { onEvent(PlayerPreferencesUiEvent.ShowDialog(null)) },
+                    ) {
+                        items(PlayerControlsStyle.entries.toTypedArray()) {
+                            RadioTextButton(
+                                modifier = Modifier.testTag("option_settings_player_controls_style_${it.name.lowercase()}"),
+                                text = it.name(),
+                                isSelected = it == uiState.preferences.controlsStyle,
+                                onClick = {
+                                    onEvent(PlayerPreferencesUiEvent.UpdateControlsStyle(it))
+                                    onEvent(PlayerPreferencesUiEvent.ShowDialog(null))
+                                },
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/player/PlayerPreferencesViewModel.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/player/PlayerPreferencesViewModel.kt
new file mode 100644
index 000000000..8345b788e
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/player/PlayerPreferencesViewModel.kt
@@ -0,0 +1,219 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.player
+
+import androidx.compose.runtime.Stable
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.common.extensions.round
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.model.ControlButtonsPosition
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControl
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerControlsStyle
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerIconStyle
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.Resume
+import app.gyrolet.mpvrx.exoplayer.core.model.ScreenOrientation
+
+class PlayerPreferencesViewModel(
+    private val preferencesRepository: PreferencesRepository,
+) : ViewModel() {
+
+    private val uiStateInternal = MutableStateFlow(
+        PlayerPreferencesUiState(
+            preferences = preferencesRepository.playerPreferences.value,
+        ),
+    )
+    val uiState = uiStateInternal.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            preferencesRepository.playerPreferences.collect { preferences ->
+                uiStateInternal.update { it.copy(preferences = preferences) }
+            }
+        }
+    }
+
+    fun onEvent(event: PlayerPreferencesUiEvent) {
+        when (event) {
+            is PlayerPreferencesUiEvent.ShowDialog -> showDialog(event.value)
+            PlayerPreferencesUiEvent.TogglePlaybackResume -> togglePlaybackResume()
+            PlayerPreferencesUiEvent.ToggleAutoplay -> toggleAutoplay()
+            PlayerPreferencesUiEvent.ToggleAutoPip -> toggleAutoPip()
+            PlayerPreferencesUiEvent.ToggleAutoBackgroundPlay -> toggleAutoBackgroundPlay()
+            PlayerPreferencesUiEvent.ToggleRememberBrightnessLevel -> toggleRememberBrightnessLevel()
+            PlayerPreferencesUiEvent.ToggleRememberPlayerScreenOrientation -> toggleRememberPlayerScreenOrientation()
+            is PlayerPreferencesUiEvent.UpdatePreferredPlayerOrientation -> updatePreferredPlayerOrientation(event.value)
+            is PlayerPreferencesUiEvent.UpdatePreferredControlButtonsPosition -> updatePreferredControlButtonsPosition(event.value)
+            is PlayerPreferencesUiEvent.UpdateDefaultPlaybackSpeed -> updateDefaultPlaybackSpeed(event.value)
+            is PlayerPreferencesUiEvent.UpdateControlAutoHideTimeout -> updateControlAutoHideTimeout(event.value)
+            is PlayerPreferencesUiEvent.UpdatePlayerIconStyle -> updatePlayerIconStyle(event.value)
+            is PlayerPreferencesUiEvent.UpdateControlsStyle -> updateControlsStyle(event.value)
+            PlayerPreferencesUiEvent.TogglePlayerControlLabels -> togglePlayerControlLabels()
+            is PlayerPreferencesUiEvent.UpdateHiddenPlayerControls -> updateHiddenPlayerControls(event.value)
+        }
+    }
+
+    private fun showDialog(value: PlayerPreferenceDialog?) {
+        uiStateInternal.update {
+            it.copy(showDialog = value)
+        }
+    }
+
+    private fun togglePlaybackResume() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(
+                    resume = when (it.resume) {
+                        Resume.YES -> Resume.NO
+                        Resume.NO -> Resume.YES
+                    },
+                )
+            }
+        }
+    }
+
+    private fun toggleAutoplay() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldAutoPlay = !it.shouldAutoPlay)
+            }
+        }
+    }
+
+    private fun toggleAutoPip() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldAutoEnterPip = !it.shouldAutoEnterPip)
+            }
+        }
+    }
+
+    private fun toggleAutoBackgroundPlay() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldAutoPlayInBackground = !it.shouldAutoPlayInBackground)
+            }
+        }
+    }
+
+    private fun toggleRememberBrightnessLevel() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldRememberPlayerBrightness = !it.shouldRememberPlayerBrightness)
+            }
+        }
+    }
+
+    private fun updatePreferredPlayerOrientation(value: ScreenOrientation) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(
+                    playerScreenOrientation = value,
+                    lastPlayerScreenOrientation = null,
+                )
+            }
+        }
+    }
+
+    private fun toggleRememberPlayerScreenOrientation() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                val shouldRememberPlayerScreenOrientation = !it.shouldRememberPlayerScreenOrientation
+                it.copy(
+                    shouldRememberPlayerScreenOrientation = shouldRememberPlayerScreenOrientation,
+                    lastPlayerScreenOrientation = null,
+                )
+            }
+        }
+    }
+
+    private fun updatePreferredControlButtonsPosition(value: ControlButtonsPosition) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(controlButtonsPosition = value)
+            }
+        }
+    }
+
+    private fun updateDefaultPlaybackSpeed(value: Float) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(defaultPlaybackSpeed = value.round(2))
+            }
+        }
+    }
+
+    private fun updateControlAutoHideTimeout(value: Int) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(controllerAutoHideTimeout = value)
+            }
+        }
+    }
+
+    private fun updatePlayerIconStyle(value: PlayerIconStyle) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(playerIconStyle = value)
+            }
+        }
+    }
+
+    private fun updateControlsStyle(value: PlayerControlsStyle) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(controlsStyle = value)
+            }
+        }
+    }
+
+    private fun togglePlayerControlLabels() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldHidePlayerControlLabels = !it.shouldHidePlayerControlLabels)
+            }
+        }
+    }
+
+    private fun updateHiddenPlayerControls(value: Set<PlayerControl>) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(hiddenPlayerControls = value)
+            }
+        }
+    }
+}
+
+@Stable
+data class PlayerPreferencesUiState(
+    val showDialog: PlayerPreferenceDialog? = null,
+    val preferences: PlayerPreferences = PlayerPreferences(),
+)
+
+sealed interface PlayerPreferenceDialog {
+    data object PlayerScreenOrientationDialog : PlayerPreferenceDialog
+    data object ControlButtonsDialog : PlayerPreferenceDialog
+    data object PlayerIconStyleDialog : PlayerPreferenceDialog
+    data object ControlsStyleDialog : PlayerPreferenceDialog
+}
+
+sealed interface PlayerPreferencesUiEvent {
+    data class ShowDialog(val value: PlayerPreferenceDialog?) : PlayerPreferencesUiEvent
+    data object TogglePlaybackResume : PlayerPreferencesUiEvent
+    data object ToggleAutoplay : PlayerPreferencesUiEvent
+    data object ToggleAutoPip : PlayerPreferencesUiEvent
+    data object ToggleAutoBackgroundPlay : PlayerPreferencesUiEvent
+    data object ToggleRememberBrightnessLevel : PlayerPreferencesUiEvent
+    data object ToggleRememberPlayerScreenOrientation : PlayerPreferencesUiEvent
+    data object TogglePlayerControlLabels : PlayerPreferencesUiEvent
+    data class UpdatePreferredPlayerOrientation(val value: ScreenOrientation) : PlayerPreferencesUiEvent
+    data class UpdatePreferredControlButtonsPosition(val value: ControlButtonsPosition) : PlayerPreferencesUiEvent
+    data class UpdateDefaultPlaybackSpeed(val value: Float) : PlayerPreferencesUiEvent
+    data class UpdateControlAutoHideTimeout(val value: Int) : PlayerPreferencesUiEvent
+    data class UpdatePlayerIconStyle(val value: PlayerIconStyle) : PlayerPreferencesUiEvent
+    data class UpdateControlsStyle(val value: PlayerControlsStyle) : PlayerPreferencesUiEvent
+    data class UpdateHiddenPlayerControls(val value: Set<PlayerControl>) : PlayerPreferencesUiEvent
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/subtitle/SubtitlePreferencesScreen.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/subtitle/SubtitlePreferencesScreen.kt
new file mode 100644
index 000000000..78939f459
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/subtitle/SubtitlePreferencesScreen.kt
@@ -0,0 +1,320 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.subtitle
+
+import android.content.Intent
+import android.provider.Settings
+import android.widget.Toast
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts.OpenDocument
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringArrayResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import java.nio.charset.Charset
+import app.gyrolet.mpvrx.R
+import app.gyrolet.mpvrx.exoplayer.core.model.Font
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ClickablePreferenceItem
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.ListSectionTitle
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.NextTopAppBar
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.OptionsDialog
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSwitch
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.PreferenceSwitchWithDivider
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.RadioTextButton
+import app.gyrolet.mpvrx.exoplayer.core.ui.components.SubtitleStylePanel
+import app.gyrolet.mpvrx.exoplayer.core.ui.designsystem.NextIcons
+import app.gyrolet.mpvrx.exoplayer.core.ui.extensions.withBottomFallback
+import app.gyrolet.mpvrx.exoplayer.settings.extensions.name
+import app.gyrolet.mpvrx.exoplayer.settings.utils.LocalesHelper
+import app.gyrolet.mpvrx.presentation.Screen
+import app.gyrolet.mpvrx.ui.icons.Icon
+import app.gyrolet.mpvrx.ui.utils.LocalBackStack
+import app.gyrolet.mpvrx.ui.utils.popSafely
+import kotlinx.serialization.Serializable
+import org.koin.compose.viewmodel.koinViewModel
+
+@Serializable
+object ExoSubtitlePreferencesScreen : Screen {
+    @Composable
+    override fun Content() {
+        val backstack = LocalBackStack.current
+        SubtitlePreferencesScreen(
+            onNavigateUp = { backstack.popSafely() }
+        )
+    }
+}
+
+@Composable
+fun SubtitlePreferencesScreen(
+    onNavigateUp: () -> Unit,
+    viewModel: SubtitlePreferencesViewModel = koinViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    SubtitlePreferencesContent(
+        uiState = uiState,
+        onEvent = viewModel::onEvent,
+        onNavigateUp = onNavigateUp,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun SubtitlePreferencesContent(
+    uiState: SubtitlePreferencesUiState,
+    onEvent: (SubtitlePreferencesUiEvent) -> Unit,
+    onNavigateUp: () -> Unit,
+) {
+    val languages = remember { listOf(Pair("None", "")) + LocalesHelper.getAvailableLocales() }
+    val charsetResource = stringArrayResource(id = R.array.charsets_list)
+    val context = LocalContext.current
+    val importFontLauncher = rememberLauncherForActivityResult(
+        contract = OpenDocument(),
+    ) { uri ->
+        onEvent(SubtitlePreferencesUiEvent.OnExternalSubtitleFontSelected(uri))
+    }
+
+    LaunchedEffect(uiState.pendingAction) {
+        when (uiState.pendingAction) {
+            SubtitlePreferencesPendingAction.OpenExternalSubtitleFontPicker -> {
+                importFontLauncher.launch(arrayOf("font/*", "application/x-font-ttf", "application/x-font-otf"))
+            }
+            null -> Unit
+        }
+    }
+
+    val importSuccessMsg = stringResource(R.string.external_subtitle_font_import_success)
+    val importFailedMsg = stringResource(R.string.external_subtitle_font_import_failed)
+    val clearSuccessMsg = stringResource(R.string.external_subtitle_font_clear_success)
+
+    LaunchedEffect(uiState.resultMessage) {
+        val message = when (uiState.resultMessage) {
+            SubtitlePreferencesResultMessage.ImportSucceeded -> importSuccessMsg
+            SubtitlePreferencesResultMessage.ImportFailed -> importFailedMsg
+            SubtitlePreferencesResultMessage.ClearSucceeded -> clearSuccessMsg
+            null -> null
+        } ?: return@LaunchedEffect
+
+        Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
+        onEvent(SubtitlePreferencesUiEvent.ClearResultMessage)
+    }
+
+    Scaffold(
+        topBar = {
+            NextTopAppBar(
+                title = stringResource(id = R.string.exo_subtitle),
+                navigationIcon = {
+                    FilledTonalIconButton(onClick = onNavigateUp) {
+                        Icon(
+                            imageVector = NextIcons.ArrowBack,
+                            contentDescription = stringResource(id = R.string.generic_cancel),
+                        )
+                    }
+                },
+            )
+        },
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .verticalScroll(state = rememberScrollState())
+                .padding(innerPadding.withBottomFallback())
+                .padding(horizontal = 16.dp),
+        ) {
+            ListSectionTitle(text = stringResource(id = R.string.subtitle_loading))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_subtitle_auto_load"),
+                    title = stringResource(id = R.string.subtitle_auto_load),
+                    description = stringResource(id = R.string.subtitle_auto_load_desc),
+                    icon = NextIcons.Subtitle,
+                    isChecked = uiState.preferences.isSubtitleAutoLoadEnabled,
+                    onClick = { onEvent(SubtitlePreferencesUiEvent.ToggleSubtitleAutoLoad) },
+                    isFirstItem = true,
+                )
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_subtitle_language"),
+                    title = stringResource(id = R.string.preferred_subtitle_lang),
+                    description = LocalesHelper.getLocaleDisplayLanguage(uiState.preferences.preferredSubtitleLanguage)
+                        .takeIf { it.isNotBlank() } ?: stringResource(R.string.preferred_subtitle_lang_description),
+                    icon = NextIcons.Language,
+                    isEnabled = uiState.preferences.isSubtitleAutoLoadEnabled,
+                    onClick = { onEvent(SubtitlePreferencesUiEvent.ShowDialog(SubtitlePreferenceDialog.SubtitleLanguageDialog)) },
+                )
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_subtitle_encoding"),
+                    title = stringResource(R.string.subtitle_text_encoding),
+                    description = charsetResource.firstOrNull { it.contains(uiState.preferences.subtitleTextEncoding) } ?: uiState.preferences.subtitleTextEncoding,
+                    icon = NextIcons.Subtitle,
+                    onClick = { onEvent(SubtitlePreferencesUiEvent.ShowDialog(SubtitlePreferenceDialog.SubtitleEncodingDialog)) },
+                    isLastItem = true,
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.subtitle_style_source))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                PreferenceSwitchWithDivider(
+                    modifier = Modifier.testTag("item_settings_subtitle_system_caption_style"),
+                    switchModifier = Modifier.testTag("switch_settings_subtitle_system_caption_style"),
+                    title = stringResource(R.string.system_caption_style),
+                    description = stringResource(R.string.system_caption_style_desc),
+                    icon = NextIcons.Caption,
+                    isChecked = uiState.preferences.shouldUseSystemCaptionStyle,
+                    onChecked = { onEvent(SubtitlePreferencesUiEvent.ToggleUseSystemCaptionStyle) },
+                    onClick = { context.startActivity(Intent(Settings.ACTION_CAPTIONING_SETTINGS)) },
+                    isFirstItem = true,
+                )
+                PreferenceSwitch(
+                    modifier = Modifier.testTag("switch_settings_subtitle_embedded_styles"),
+                    title = stringResource(R.string.embedded_styles),
+                    description = stringResource(R.string.embedded_styles_desc),
+                    icon = NextIcons.Style,
+                    isChecked = uiState.preferences.shouldApplyEmbeddedStyles,
+                    onClick = { onEvent(SubtitlePreferencesUiEvent.ToggleApplyEmbeddedStyles) },
+                    isLastItem = uiState.preferences.shouldUseSystemCaptionStyle.not(),
+                )
+                if (uiState.preferences.shouldUseSystemCaptionStyle) {
+                    ClickablePreferenceItem(
+                        title = stringResource(id = R.string.external_subtitle_font_notice_title),
+                        description = stringResource(id = R.string.external_subtitle_font_system_style_notice),
+                        icon = NextIcons.Info,
+                        isEnabled = false,
+                        isLastItem = true,
+                    )
+                }
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.subtitle_font_settings))
+            Column(
+                verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+            ) {
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_subtitle_font"),
+                    title = stringResource(id = R.string.subtitle_font),
+                    description = uiState.preferences.subtitleFont.name(),
+                    icon = NextIcons.Font,
+                    isEnabled = uiState.preferences.shouldUseSystemCaptionStyle.not(),
+                    onClick = { onEvent(SubtitlePreferencesUiEvent.ShowDialog(SubtitlePreferenceDialog.SubtitleFontDialog)) },
+                    isFirstItem = true,
+                )
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_subtitle_import_external_font"),
+                    title = stringResource(id = R.string.external_subtitle_font_import),
+                    description = stringResource(id = R.string.external_subtitle_font_import_desc),
+                    icon = NextIcons.FileOpen,
+                    onClick = { onEvent(SubtitlePreferencesUiEvent.ImportExternalSubtitleFont) },
+                )
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_subtitle_current_external_font"),
+                    title = stringResource(id = R.string.external_subtitle_font_current),
+                    description = uiState.externalFontName.ifBlank { stringResource(id = R.string.external_subtitle_font_not_imported) },
+                    icon = NextIcons.Font,
+                    isEnabled = false,
+                )
+                ClickablePreferenceItem(
+                    modifier = Modifier.testTag("item_settings_subtitle_clear_external_font"),
+                    title = stringResource(id = R.string.external_subtitle_font_clear),
+                    description = stringResource(id = R.string.external_subtitle_font_clear_desc),
+                    icon = NextIcons.DeleteSweep,
+                    isEnabled = uiState.isExternalFontAvailable,
+                    onClick = { onEvent(SubtitlePreferencesUiEvent.ClearExternalSubtitleFont) },
+                    isLastItem = true,
+                )
+            }
+
+            ListSectionTitle(text = stringResource(id = R.string.subtitle_appearance))
+            SubtitleStylePanel(
+                preferences = uiState.preferences,
+                onPreferencesChange = { onEvent(SubtitlePreferencesUiEvent.UpdateSubtitleStyle(it)) },
+            )
+        }
+
+        uiState.showDialog?.let { showDialog ->
+            when (showDialog) {
+                SubtitlePreferenceDialog.SubtitleLanguageDialog -> {
+                    OptionsDialog(
+                        title = stringResource(id = R.string.preferred_subtitle_lang),
+                        onDismissClick = { onEvent(SubtitlePreferencesUiEvent.ShowDialog(null)) },
+                    ) {
+                        items(languages) {
+                            RadioTextButton(
+                                modifier = Modifier.testTag("option_settings_subtitle_language_${it.second.ifBlank { "none" }}"),
+                                text = it.first,
+                                isSelected = it.second == uiState.preferences.preferredSubtitleLanguage,
+                                onClick = {
+                                    onEvent(SubtitlePreferencesUiEvent.UpdateSubtitleLanguage(it.second))
+                                    onEvent(SubtitlePreferencesUiEvent.ShowDialog(null))
+                                },
+                            )
+                        }
+                    }
+                }
+
+                SubtitlePreferenceDialog.SubtitleFontDialog -> {
+                    OptionsDialog(
+                        title = stringResource(id = R.string.subtitle_font),
+                        onDismissClick = { onEvent(SubtitlePreferencesUiEvent.ShowDialog(null)) },
+                    ) {
+                        items(Font.entries.toTypedArray()) {
+                            RadioTextButton(
+                                modifier = Modifier.testTag("option_settings_subtitle_font_${it.name.lowercase()}"),
+                                text = it.name(),
+                                isSelected = it == uiState.preferences.subtitleFont,
+                                onClick = {
+                                    onEvent(SubtitlePreferencesUiEvent.UpdateSubtitleFont(it))
+                                    onEvent(SubtitlePreferencesUiEvent.ShowDialog(null))
+                                },
+                            )
+                        }
+                    }
+                }
+
+                SubtitlePreferenceDialog.SubtitleEncodingDialog -> {
+                    OptionsDialog(
+                        title = stringResource(id = R.string.subtitle_text_encoding),
+                        onDismissClick = { onEvent(SubtitlePreferencesUiEvent.ShowDialog(null)) },
+                    ) {
+                        items(charsetResource) {
+                            val currentCharset = it.substringAfterLast("(", "").removeSuffix(")")
+                            if (currentCharset.isEmpty() || Charset.isSupported(currentCharset)) {
+                                RadioTextButton(
+                                    modifier = Modifier.testTag("option_settings_subtitle_encoding_$currentCharset"),
+                                    text = it,
+                                    isSelected = currentCharset == uiState.preferences.subtitleTextEncoding,
+                                    onClick = {
+                                        onEvent(SubtitlePreferencesUiEvent.UpdateSubtitleEncoding(currentCharset))
+                                        onEvent(SubtitlePreferencesUiEvent.ShowDialog(null))
+                                    },
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/subtitle/SubtitlePreferencesViewModel.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/subtitle/SubtitlePreferencesViewModel.kt
new file mode 100644
index 000000000..31e886596
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/screens/subtitle/SubtitlePreferencesViewModel.kt
@@ -0,0 +1,226 @@
+package app.gyrolet.mpvrx.exoplayer.settings.screens.subtitle
+
+import android.net.Uri
+import androidx.compose.runtime.Stable
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.PreferencesRepository
+import app.gyrolet.mpvrx.exoplayer.core.data.repository.SubtitleFontRepository
+import app.gyrolet.mpvrx.exoplayer.core.model.Font
+import app.gyrolet.mpvrx.exoplayer.core.model.PlayerPreferences
+import app.gyrolet.mpvrx.exoplayer.core.model.withSubtitleStyleFrom
+
+class SubtitlePreferencesViewModel(
+    private val preferencesRepository: PreferencesRepository,
+    private val subtitleFontRepository: SubtitleFontRepository,
+) : ViewModel() {
+
+    private val uiStateInternal = MutableStateFlow(
+        SubtitlePreferencesUiState(
+            preferences = preferencesRepository.playerPreferences.value,
+        ),
+    )
+    val uiState = uiStateInternal.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            preferencesRepository.playerPreferences.collect { preferences ->
+                uiStateInternal.update { currentState ->
+                    currentState.copy(preferences = preferences)
+                }
+            }
+        }
+        viewModelScope.launch {
+            subtitleFontRepository.state.collect { state ->
+                uiStateInternal.update { currentState ->
+                    currentState.copy(
+                        externalFontName = state.displayName,
+                        isExternalFontAvailable = state.isAvailable,
+                    )
+                }
+            }
+        }
+    }
+
+    fun onEvent(event: SubtitlePreferencesUiEvent) {
+        when (event) {
+            is SubtitlePreferencesUiEvent.ShowDialog -> showDialog(event.value)
+            SubtitlePreferencesUiEvent.ToggleSubtitleAutoLoad -> toggleSubtitleAutoLoad()
+            is SubtitlePreferencesUiEvent.UpdateSubtitleLanguage -> updateSubtitleLanguage(event.value)
+            is SubtitlePreferencesUiEvent.UpdateSubtitleFont -> updateSubtitleFont(event.value)
+            SubtitlePreferencesUiEvent.ToggleSubtitleTextBold -> toggleSubtitleTextBold()
+            is SubtitlePreferencesUiEvent.UpdateSubtitleFontSize -> updateSubtitleFontSize(event.value)
+            is SubtitlePreferencesUiEvent.UpdateSubtitleStyle -> updateSubtitleStyle(event.preferences)
+            SubtitlePreferencesUiEvent.ToggleSubtitleBackground -> toggleSubtitleBackground()
+            SubtitlePreferencesUiEvent.ToggleApplyEmbeddedStyles -> toggleApplyEmbeddedStyles()
+            is SubtitlePreferencesUiEvent.UpdateSubtitleEncoding -> updateSubtitleEncoding(event.value)
+            SubtitlePreferencesUiEvent.ToggleUseSystemCaptionStyle -> toggleUseSystemCaptionStyle()
+            SubtitlePreferencesUiEvent.ImportExternalSubtitleFont -> importExternalSubtitleFont()
+            is SubtitlePreferencesUiEvent.OnExternalSubtitleFontSelected -> onExternalSubtitleFontSelected(event.uri)
+            SubtitlePreferencesUiEvent.ClearExternalSubtitleFont -> clearExternalSubtitleFont()
+            SubtitlePreferencesUiEvent.ClearResultMessage -> clearResultMessage()
+        }
+    }
+
+    private fun showDialog(value: SubtitlePreferenceDialog?) {
+        uiStateInternal.update {
+            it.copy(showDialog = value)
+        }
+    }
+
+    private fun toggleSubtitleAutoLoad() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(isSubtitleAutoLoadEnabled = !it.isSubtitleAutoLoadEnabled)
+            }
+        }
+    }
+
+    private fun updateSubtitleLanguage(value: String) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(preferredSubtitleLanguage = value)
+            }
+        }
+    }
+
+    private fun updateSubtitleFont(value: Font) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(subtitleFont = value)
+            }
+        }
+    }
+
+    private fun toggleSubtitleTextBold() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldUseBoldSubtitleText = !it.shouldUseBoldSubtitleText)
+            }
+        }
+    }
+
+    private fun updateSubtitleFontSize(value: Int) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(subtitleTextSize = value)
+            }
+        }
+    }
+
+    private fun toggleSubtitleBackground() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldShowSubtitleBackground = !it.shouldShowSubtitleBackground)
+            }
+        }
+    }
+
+    private fun updateSubtitleStyle(preferences: PlayerPreferences) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.withSubtitleStyleFrom(preferences)
+            }
+        }
+    }
+
+    private fun toggleApplyEmbeddedStyles() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences {
+                it.copy(shouldApplyEmbeddedStyles = !it.shouldApplyEmbeddedStyles)
+            }
+        }
+    }
+
+    private fun updateSubtitleEncoding(value: String) {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences { it.copy(subtitleTextEncoding = value) }
+        }
+    }
+
+    private fun toggleUseSystemCaptionStyle() {
+        viewModelScope.launch {
+            preferencesRepository.updatePlayerPreferences { it.copy(shouldUseSystemCaptionStyle = !it.shouldUseSystemCaptionStyle) }
+        }
+    }
+
+    private fun importExternalSubtitleFont() {
+        uiStateInternal.update {
+            it.copy(pendingAction = SubtitlePreferencesPendingAction.OpenExternalSubtitleFontPicker)
+        }
+    }
+
+    private fun onExternalSubtitleFontSelected(uri: Uri?) {
+        uiStateInternal.update { it.copy(pendingAction = null) }
+        if (uri == null) return
+
+        viewModelScope.launch {
+            runCatching {
+                subtitleFontRepository.importFont(uri)
+            }.onSuccess {
+                uiStateInternal.update { it.copy(resultMessage = SubtitlePreferencesResultMessage.ImportSucceeded) }
+            }.onFailure {
+                uiStateInternal.update { it.copy(resultMessage = SubtitlePreferencesResultMessage.ImportFailed) }
+            }
+        }
+    }
+
+    private fun clearExternalSubtitleFont() {
+        viewModelScope.launch {
+            subtitleFontRepository.clearFont()
+            uiStateInternal.update { it.copy(resultMessage = SubtitlePreferencesResultMessage.ClearSucceeded) }
+        }
+    }
+
+    private fun clearResultMessage() {
+        uiStateInternal.update { it.copy(resultMessage = null) }
+    }
+}
+
+@Stable
+data class SubtitlePreferencesUiState(
+    val showDialog: SubtitlePreferenceDialog? = null,
+    val preferences: PlayerPreferences = PlayerPreferences(),
+    val externalFontName: String = "",
+    val isExternalFontAvailable: Boolean = false,
+    val pendingAction: SubtitlePreferencesPendingAction? = null,
+    val resultMessage: SubtitlePreferencesResultMessage? = null,
+)
+
+sealed interface SubtitlePreferenceDialog {
+    data object SubtitleLanguageDialog : SubtitlePreferenceDialog
+    data object SubtitleFontDialog : SubtitlePreferenceDialog
+    data object SubtitleEncodingDialog : SubtitlePreferenceDialog
+}
+
+sealed interface SubtitlePreferencesPendingAction {
+    data object OpenExternalSubtitleFontPicker : SubtitlePreferencesPendingAction
+}
+
+sealed interface SubtitlePreferencesResultMessage {
+    data object ImportSucceeded : SubtitlePreferencesResultMessage
+    data object ImportFailed : SubtitlePreferencesResultMessage
+    data object ClearSucceeded : SubtitlePreferencesResultMessage
+}
+
+sealed interface SubtitlePreferencesUiEvent {
+    data class ShowDialog(val value: SubtitlePreferenceDialog?) : SubtitlePreferencesUiEvent
+    data object ToggleSubtitleAutoLoad : SubtitlePreferencesUiEvent
+    data class UpdateSubtitleLanguage(val value: String) : SubtitlePreferencesUiEvent
+    data class UpdateSubtitleFont(val value: Font) : SubtitlePreferencesUiEvent
+    data object ToggleSubtitleTextBold : SubtitlePreferencesUiEvent
+    data class UpdateSubtitleFontSize(val value: Int) : SubtitlePreferencesUiEvent
+    data class UpdateSubtitleStyle(val preferences: PlayerPreferences) : SubtitlePreferencesUiEvent
+    data object ToggleSubtitleBackground : SubtitlePreferencesUiEvent
+    data object ToggleApplyEmbeddedStyles : SubtitlePreferencesUiEvent
+    data class UpdateSubtitleEncoding(val value: String) : SubtitlePreferencesUiEvent
+    data object ToggleUseSystemCaptionStyle : SubtitlePreferencesUiEvent
+    data object ImportExternalSubtitleFont : SubtitlePreferencesUiEvent
+    data class OnExternalSubtitleFontSelected(val uri: Uri?) : SubtitlePreferencesUiEvent
+    data object ClearExternalSubtitleFont : SubtitlePreferencesUiEvent
+    data object ClearResultMessage : SubtitlePreferencesUiEvent
+}
diff --git a/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/utils/LocalesHelper.kt b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/utils/LocalesHelper.kt
new file mode 100644
index 000000000..37f502247
--- /dev/null
+++ b/app/src/main/kotlin/app/gyrolet/mpvrx/exoplayer/settings/utils/LocalesHelper.kt
@@ -0,0 +1,51 @@
+package app.gyrolet.mpvrx.exoplayer.settings.utils
+
+import java.util.Locale
+import app.gyrolet.mpvrx.exoplayer.core.common.Logger
+
+object LocalesHelper {
+
+    val appSupportedLocales: List<Pair<String, String>> = listOf(
+        Pair("English", "en"),
+        Pair("简体中文", "zh-CN"),
+        Pair("繁體中文", "zh-TW"),
+    )
+
+    private val chineseVariants = listOf(
+        Pair("中文（简体）", "zh-Hans"),
+        Pair("中文（繁體）", "zh-Hant"),
+    )
+
+    fun getAvailableLocales(): List<Pair<String, String>> = try {
+        val baseLocales = Locale.getAvailableLocales()
+            .filter { it.language.isNotBlank() && it.language != "und" }
+            .map { Pair(it.displayLanguage, it.language) }
+            .filter { (name, code) -> name != code && name.isNotBlank() }
+            .distinctBy { it.second }
+            .filter { it.second != "zh" }
+            .sortedBy { it.first }
+        baseLocales + chineseVariants
+    } catch (e: Exception) {
+        Logger.error(TAG, "Failed to load available locales", e)
+        listOf()
+    }
+
+    fun getLocaleDisplayLanguage(key: String): String = try {
+        if (key.isBlank()) return ""
+
+        chineseVariants.firstOrNull { it.second == key }?.first?.let { return it }
+
+        Locale.getAvailableLocales().firstOrNull { locale ->
+            locale.isO3Language == key || locale.language == key
+        }?.displayLanguage.orEmpty()
+    } catch (e: Exception) {
+        Logger.error(TAG, "Failed to resolve locale display language: $key", e)
+        ""
+    }
+
+    fun getAppLocaleDisplayName(languageTag: String): String = appSupportedLocales.firstOrNull {
+        it.second == languageTag
+    }?.first.orEmpty()
+
+    private const val TAG = "LocalesHelper"
+}
diff --git a/app/src/main/res/drawable/artwork_default.png b/app/src/main/res/drawable/artwork_default.png
new file mode 100644
index 000000000..d8903eab9
Binary files /dev/null and b/app/src/main/res/drawable/artwork_default.png differ
diff --git a/app/src/main/res/drawable/circle_background.xml b/app/src/main/res/drawable/circle_background.xml
new file mode 100644
index 000000000..6da523d02
--- /dev/null
+++ b/app/src/main/res/drawable/circle_background.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="oval">
+    <solid android:color="?attr/colorPrimary" />
+</shape>
\ No newline at end of file
diff --git a/app/src/main/res/drawable/folder_thumb.xml b/app/src/main/res/drawable/folder_thumb.xml
new file mode 100644
index 000000000..330ebba97
--- /dev/null
+++ b/app/src/main/res/drawable/folder_thumb.xml
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="20dp"
+    android:height="17dp"
+    android:viewportWidth="20"
+    android:viewportHeight="17">
+  <path
+      android:pathData="M2.197,16.453C1.601,16.453 1.094,16.244 0.675,15.825C0.256,15.406 0.047,14.899 0.047,14.303V2.697C0.047,2.101 0.256,1.594 0.675,1.175C1.094,0.756 1.601,0.547 2.197,0.547H7.147C7.435,0.547 7.71,0.602 7.973,0.711C8.236,0.821 8.468,0.977 8.669,1.18L10,2.511H17.803C18.399,2.511 18.906,2.721 19.325,3.14C19.744,3.559 19.953,4.066 19.953,4.661V14.303C19.953,14.899 19.744,15.406 19.325,15.825C18.906,16.244 18.399,16.453 17.803,16.453H2.197Z"
+      android:fillColor="#ffffff"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_add.xml b/app/src/main/res/drawable/ic_add.xml
new file mode 100644
index 000000000..37c166cb0
--- /dev/null
+++ b/app/src/main/res/drawable/ic_add.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M18,13h-5v5c0,0.55 -0.45,1 -1,1s-1,-0.45 -1,-1v-5H6c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1h5V6c0,-0.55 0.45,-1 1,-1s1,0.45 1,1v5h5c0.55,0 1,0.45 1,1s-0.45,1 -1,1z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_arrow_left.xml b/app/src/main/res/drawable/ic_arrow_left.xml
new file mode 100644
index 000000000..23f6fe4de
--- /dev/null
+++ b/app/src/main/res/drawable/ic_arrow_left.xml
@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:tint="#FFFFFF" android:viewportHeight="24"
+    android:viewportWidth="24" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M19,11H7.83l4.88,-4.88c0.39,-0.39 0.39,-1.03 0,-1.42 -0.39,-0.39 -1.02,-0.39 -1.41,0l-6.59,6.59c-0.39,0.39 -0.39,1.02 0,1.41l6.59,6.59c0.39,0.39 1.02,0.39 1.41,0 0.39,-0.39 0.39,-1.02 0,-1.41L7.83,13H19c0.55,0 1,-0.45 1,-1s-0.45,-1 -1,-1z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_aspect_ratio.xml b/app/src/main/res/drawable/ic_aspect_ratio.xml
new file mode 100644
index 000000000..df3e52da1
--- /dev/null
+++ b/app/src/main/res/drawable/ic_aspect_ratio.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M18,12c-0.55,0 -1,0.45 -1,1v2h-2c-0.55,0 -1,0.45 -1,1s0.45,1 1,1h3c0.55,0 1,-0.45 1,-1v-3c0,-0.55 -0.45,-1 -1,-1zM7,9h2c0.55,0 1,-0.45 1,-1s-0.45,-1 -1,-1L6,7c-0.55,0 -1,0.45 -1,1v3c0,0.55 0.45,1 1,1s1,-0.45 1,-1L7,9zM21,3L3,3c-1.1,0 -2,0.9 -2,2v14c0,1.1 0.9,2 2,2h18c1.1,0 2,-0.9 2,-2L23,5c0,-1.1 -0.9,-2 -2,-2zM20,19.01L4,19.01c-0.55,0 -1,-0.45 -1,-1L3,5.99c0,-0.55 0.45,-1 1,-1h16c0.55,0 1,0.45 1,1v12.02c0,0.55 -0.45,1 -1,1z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_audio_track.xml b/app/src/main/res/drawable/ic_audio_track.xml
new file mode 100644
index 000000000..a014c81d6
--- /dev/null
+++ b/app/src/main/res/drawable/ic_audio_track.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M12,5v8.55c-0.94,-0.54 -2.1,-0.75 -3.33,-0.32 -1.34,0.48 -2.37,1.67 -2.61,3.07 -0.46,2.74 1.86,5.08 4.59,4.65 1.96,-0.31 3.35,-2.11 3.35,-4.1V7h2c1.1,0 2,-0.9 2,-2s-0.9,-2 -2,-2h-2c-1.1,0 -2,0.9 -2,2z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_brightness.xml b/app/src/main/res/drawable/ic_brightness.xml
new file mode 100644
index 000000000..b98bfff1c
--- /dev/null
+++ b/app/src/main/res/drawable/ic_brightness.xml
@@ -0,0 +1,12 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:width="24dp"
+    android:height="24dp"
+    android:tint="#FFFFFF"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M12,7c-2.76,0 -5,2.24 -5,5s2.24,5 5,5s5,-2.24 5,-5S14.76,7 12,7L12,7zM2,13l2,0c0.55,0 1,-0.45 1,-1s-0.45,-1 -1,-1l-2,0c-0.55,0 -1,0.45 -1,1S1.45,13 2,13zM20,13l2,0c0.55,0 1,-0.45 1,-1s-0.45,-1 -1,-1l-2,0c-0.55,0 -1,0.45 -1,1S19.45,13 20,13zM11,2v2c0,0.55 0.45,1 1,1s1,-0.45 1,-1V2c0,-0.55 -0.45,-1 -1,-1S11,1.45 11,2zM11,20v2c0,0.55 0.45,1 1,1s1,-0.45 1,-1v-2c0,-0.55 -0.45,-1 -1,-1C11.45,19 11,19.45 11,20zM5.99,4.58c-0.39,-0.39 -1.03,-0.39 -1.41,0c-0.39,0.39 -0.39,1.03 0,1.41l1.06,1.06c0.39,0.39 1.03,0.39 1.41,0s0.39,-1.03 0,-1.41L5.99,4.58zM18.36,16.95c-0.39,-0.39 -1.03,-0.39 -1.41,0c-0.39,0.39 -0.39,1.03 0,1.41l1.06,1.06c0.39,0.39 1.03,0.39 1.41,0c0.39,-0.39 0.39,-1.03 0,-1.41L18.36,16.95zM19.42,5.99c0.39,-0.39 0.39,-1.03 0,-1.41c-0.39,-0.39 -1.03,-0.39 -1.41,0l-1.06,1.06c-0.39,0.39 -0.39,1.03 0,1.41s1.03,0.39 1.41,0L19.42,5.99zM7.05,18.36c0.39,-0.39 0.39,-1.03 0,-1.41c-0.39,-0.39 -1.03,-0.39 -1.41,0l-1.06,1.06c-0.39,0.39 -0.39,1.03 0,1.41s1.03,0.39 1.41,0L7.05,18.36z"
+        tools:ignore="VectorPath" />
+</vector>
diff --git a/app/src/main/res/drawable/ic_close.xml b/app/src/main/res/drawable/ic_close.xml
new file mode 100644
index 000000000..0323b7f4f
--- /dev/null
+++ b/app/src/main/res/drawable/ic_close.xml
@@ -0,0 +1,5 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24" android:viewportWidth="24" android:width="24dp">
+      
+    <path android:fillColor="@android:color/white" android:pathData="M18.3,5.71c-0.39,-0.39 -1.02,-0.39 -1.41,0L12,10.59 7.11,5.7c-0.39,-0.39 -1.02,-0.39 -1.41,0 -0.39,0.39 -0.39,1.02 0,1.41L10.59,12 5.7,16.89c-0.39,0.39 -0.39,1.02 0,1.41 0.39,0.39 1.02,0.39 1.41,0L12,13.41l4.89,4.89c0.39,0.39 1.02,0.39 1.41,0 0.39,-0.39 0.39,-1.02 0,-1.41L13.41,12l4.89,-4.89c0.38,-0.38 0.38,-1.02 0,-1.4z"/>
+    
+</vector>
diff --git a/app/src/main/res/drawable/ic_crop_landscape.xml b/app/src/main/res/drawable/ic_crop_landscape.xml
new file mode 100644
index 000000000..9b5bda1f7
--- /dev/null
+++ b/app/src/main/res/drawable/ic_crop_landscape.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M19,5L5,5c-1.1,0 -2,0.9 -2,2v10c0,1.1 0.9,2 2,2h14c1.1,0 2,-0.9 2,-2L21,7c0,-1.1 -0.9,-2 -2,-2zM18,17L6,17c-0.55,0 -1,-0.45 -1,-1L5,8c0,-0.55 0.45,-1 1,-1h12c0.55,0 1,0.45 1,1v8c0,0.55 -0.45,1 -1,1z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_drag_handle.xml b/app/src/main/res/drawable/ic_drag_handle.xml
new file mode 100644
index 000000000..b1efdec26
--- /dev/null
+++ b/app/src/main/res/drawable/ic_drag_handle.xml
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M20,9H4v2h16V9zM4,15h16v-2H4V15z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_fast.xml b/app/src/main/res/drawable/ic_fast.xml
new file mode 100644
index 000000000..072b7aee0
--- /dev/null
+++ b/app/src/main/res/drawable/ic_fast.xml
@@ -0,0 +1,12 @@
+<vector
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:tint="#ffffff"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M5.58,16.89L11.35,12.82C11.91,12.42 11.91,11.58 11.35,11.18L5.58,7.11C4.91,6.65 4,7.12 4,7.93L4,16.07C4,16.88 4.91,17.35 5.58,16.89M13,7.93L13,16.07C13,16.88 13.91,17.35 14.58,16.89L20.35,12.82C20.91,12.42 20.91,11.58 20.35,11.18L14.58,7.11C13.91,6.65 13,7.12 13,7.93" />
+</vector>
diff --git a/app/src/main/res/drawable/ic_fit_screen.xml b/app/src/main/res/drawable/ic_fit_screen.xml
new file mode 100644
index 000000000..33ec370ed
--- /dev/null
+++ b/app/src/main/res/drawable/ic_fit_screen.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M18,4h2c1.1,0 2,0.9 2,2v2c0,0.55 -0.45,1 -1,1h0c-0.55,0 -1,-0.45 -1,-1V6h-2c-0.55,0 -1,-0.45 -1,-1v0C17,4.45 17.45,4 18,4zM4,8l0,-2h2c0.55,0 1,-0.45 1,-1v0c0,-0.55 -0.45,-1 -1,-1H4C2.9,4 2,4.9 2,6l0,2c0,0.55 0.45,1 1,1h0C3.55,9 4,8.55 4,8zM20,16v2h-2c-0.55,0 -1,0.45 -1,1v0c0,0.55 0.45,1 1,1h2c1.1,0 2,-0.9 2,-2v-2c0,-0.55 -0.45,-1 -1,-1h0C20.45,15 20,15.45 20,16zM6,18H4v-2c0,-0.55 -0.45,-1 -1,-1h0c-0.55,0 -1,0.45 -1,1v2c0,1.1 0.9,2 2,2h2c0.55,0 1,-0.45 1,-1v0C7,18.45 6.55,18 6,18zM16,8H8c-1.1,0 -2,0.9 -2,2v4c0,1.1 0.9,2 2,2h8c1.1,0 2,-0.9 2,-2v-4C18,8.9 17.1,8 16,8z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_github.xml b/app/src/main/res/drawable/ic_github.xml
new file mode 100644
index 000000000..6a3cad3e8
--- /dev/null
+++ b/app/src/main/res/drawable/ic_github.xml
@@ -0,0 +1,12 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="150dp"
+    android:height="148dp"
+    android:viewportWidth="150"
+    android:viewportHeight="148">
+    <group>
+        <path
+            android:fillColor="#FF24292F"
+            android:fillType="evenOdd"
+            android:pathData="M74.78 0.53C33.43 0.53 0 34.2 0 75.86c0 33.3 21.42 61.5 51.13 71.47 3.71 0.75 5.08-1.62 5.08-3.62 0-1.75-0.13-7.73-0.13-13.97-20.8 4.5-25.13-8.98-25.13-8.98-3.34-8.73-8.3-10.97-8.3-10.97-6.8-4.62 0.5-4.62 0.5-4.62 7.55 0.5 11.52 7.73 11.52 7.73 6.68 11.48 17.45 8.24 21.78 6.24 0.62-4.86 2.6-8.23 4.7-10.1-16.58-1.75-34.04-8.23-34.04-37.17 0-8.23 2.97-14.97 7.68-20.2-0.74-1.87-3.35-9.6 0.74-19.96 0 0 6.32-2 20.55 7.73 6.1-1.65 12.38-2.48 18.7-2.5 6.31 0 12.75 0.88 18.69 2.5 14.24-9.73 20.55-7.73 20.55-7.73 4.09 10.35 1.49 18.09 0.74 19.96 4.83 5.23 7.68 11.97 7.68 20.2 0 28.94-17.45 35.3-34.17 37.17 2.72 2.37 5.08 6.86 5.08 13.97 0 10.1-0.13 18.2-0.13 20.7 0 2 1.37 4.37 5.08 3.62 29.71-9.98 51.13-38.17 51.13-71.47C149.55 34.2 116 0.53 74.78 0.53Z"/>
+    </group>
+</vector>
diff --git a/app/src/main/res/drawable/ic_headset.xml b/app/src/main/res/drawable/ic_headset.xml
new file mode 100644
index 000000000..5ff299063
--- /dev/null
+++ b/app/src/main/res/drawable/ic_headset.xml
@@ -0,0 +1,5 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24" android:viewportWidth="24" android:width="24dp">
+      
+    <path android:fillColor="@android:color/white" android:pathData="M11.4,1.02C6.62,1.33 3,5.52 3,10.31V17c0,1.66 1.34,3 3,3h1c1.1,0 2,-0.9 2,-2v-4c0,-1.1 -0.9,-2 -2,-2H5v-1.71C5,6.45 7.96,3.11 11.79,3 15.76,2.89 19,6.06 19,10v2h-2c-1.1,0 -2,0.9 -2,2v4c0,1.1 0.9,2 2,2h1c1.66,0 3,-1.34 3,-3v-7c0,-5.17 -4.36,-9.32 -9.6,-8.98z"/>
+    
+</vector>
diff --git a/app/src/main/res/drawable/ic_kofi.xml b/app/src/main/res/drawable/ic_kofi.xml
new file mode 100644
index 000000000..4eeaedde5
--- /dev/null
+++ b/app/src/main/res/drawable/ic_kofi.xml
@@ -0,0 +1,35 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="40dp"
+    android:height="40dp"
+    android:viewportWidth="40"
+    android:viewportHeight="40">
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:strokeColor="#FF000000"
+        android:strokeWidth="1.14"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round"
+        android:pathData="M29.9 21.9c-0.73 0.09-1.47 0.12-2.2 0.1v-7.2h1.5c0.48-0.02 0.96 0.08 1.4 0.3 0.43 0.2 0.81 0.51 1.1 0.9 0.53 0.65 0.81 1.46 0.8 2.3 0.08 0.81-0.14 1.63-0.62 2.3-0.48 0.66-1.18 1.12-1.98 1.3Zm6.2-5c-0.14-0.91-0.47-1.78-0.97-2.56s-1.16-1.44-1.93-1.94c-1.29-0.9-2.82-1.4-4.4-1.4h-22c-0.3 0.04-0.56 0.18-0.77 0.4-0.2 0.22-0.31 0.5-0.33 0.8v0.3s-0.1 9.7 0.1 15c0.05 0.84 0.42 1.63 1.03 2.2 0.62 0.58 1.43 0.9 2.27 0.9 0 0 10.1 0 14.9-0.1h0.7c2.8-0.7 3-3.3 3-4.7 5.5 0.2 9.4-3.7 8.4-8.9Z"/>
+    <path
+        android:fillColor="#FFFF5E5B"
+        android:pathData="M16.5 26.4c0.3 0.1 0.4 0 0.4 0s3.5-3.2 5.1-5.1c1.4-1.7 1.5-4.4-0.9-5.5-2.4-1.1-4.4 1.2-4.4 1.2-0.65-0.8-1.6-1.32-2.63-1.43-1.03-0.11-2.06 0.19-2.87 0.83l-0.1 0.1c-1.2 1.3-0.8 3.5 0.1 4.7 1.6 1.77 3.3 3.44 5.1 5l0.2 0.2Z"/>
+    <path
+        android:pathData="M16.7 26.5c0.05 0 0.1 0 0.16-0.02 0.05-0.01 0.1-0.04 0.14-0.08 0 0 3.5-3.2 5.1-5.1 1.4-1.7 1.5-4.4-0.9-5.5-2.4-1.1-4.4 1.2-4.4 1.2-0.65-0.8-1.6-1.32-2.63-1.43-1.03-0.11-2.06 0.19-2.87 0.83l-0.1 0.1c-1.2 1.3-0.8 3.5 0.1 4.7 1.63 1.8 3.37 3.5 5.2 5.1 0 0.2 0.1 0.2 0.2 0.2Z">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:type="linear"
+                android:startX="13.31"
+                android:startY="8.09"
+                android:endX="17.46"
+                android:endY="20.83">
+                <item
+                    android:color="#FFFF4EA3"
+                    android:offset="0"/>
+                <item
+                    android:color="#FFFF5E5B"
+                    android:offset="1"/>
+            </gradient>
+        </aapt:attr>
+    </path>
+</vector>
diff --git a/app/src/main/res/drawable/ic_landscape.xml b/app/src/main/res/drawable/ic_landscape.xml
new file mode 100644
index 000000000..bb2bd2085
--- /dev/null
+++ b/app/src/main/res/drawable/ic_landscape.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M1.01,7L1,17c0,1.1 0.9,2 2,2h18c1.1,0 2,-0.9 2,-2V7c0,-1.1 -0.9,-2 -2,-2H3c-1.1,0 -1.99,0.9 -1.99,2zM19,7v10H5V7h14z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_lock.xml b/app/src/main/res/drawable/ic_lock.xml
new file mode 100644
index 000000000..d8f6120cf
--- /dev/null
+++ b/app/src/main/res/drawable/ic_lock.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M18,8h-1L17,6c0,-2.76 -2.24,-5 -5,-5S7,3.24 7,6v2L6,8c-1.1,0 -2,0.9 -2,2v10c0,1.1 0.9,2 2,2h12c1.1,0 2,-0.9 2,-2L20,10c0,-1.1 -0.9,-2 -2,-2zM9,6c0,-1.66 1.34,-3 3,-3s3,1.34 3,3v2L9,8L9,6zM18,20L6,20L6,10h12v10zM12,17c1.1,0 2,-0.9 2,-2s-0.9,-2 -2,-2 -2,0.9 -2,2 0.9,2 2,2z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_lock_open.xml b/app/src/main/res/drawable/ic_lock_open.xml
new file mode 100644
index 000000000..e9f717c5e
--- /dev/null
+++ b/app/src/main/res/drawable/ic_lock_open.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M12,13c-1.1,0 -2,0.9 -2,2s0.9,2 2,2 2,-0.9 2,-2 -0.9,-2 -2,-2zM18,8h-1L17,6c0,-2.76 -2.24,-5 -5,-5 -2.28,0 -4.27,1.54 -4.84,3.75 -0.14,0.54 0.18,1.08 0.72,1.22 0.53,0.14 1.08,-0.18 1.22,-0.72C9.44,3.93 10.63,3 12,3c1.65,0 3,1.35 3,3v2L6,8c-1.1,0 -2,0.9 -2,2v10c0,1.1 0.9,2 2,2h12c1.1,0 2,-0.9 2,-2L20,10c0,-1.1 -0.9,-2 -2,-2zM18,19c0,0.55 -0.45,1 -1,1L7,20c-0.55,0 -1,-0.45 -1,-1v-8c0,-0.55 0.45,-1 1,-1h10c0.55,0 1,0.45 1,1v8z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_loop_all.xml b/app/src/main/res/drawable/ic_loop_all.xml
new file mode 100644
index 000000000..3843228f0
--- /dev/null
+++ b/app/src/main/res/drawable/ic_loop_all.xml
@@ -0,0 +1,12 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:tint="#FFFFFF"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M7,7h10v1.79c0,0.45 0.54,0.67 0.85,0.35l2.79,-2.79c0.2,-0.2 0.2,-0.51 0,-0.71l-2.79,-2.79c-0.31,-0.31 -0.85,-0.09 -0.85,0.36L17,5L6,5c-0.55,0 -1,0.45 -1,1v4c0,0.55 0.45,1 1,1s1,-0.45 1,-1L7,7zM17,17L7,17v-1.79c0,-0.45 -0.54,-0.67 -0.85,-0.35l-2.79,2.79c-0.2,0.2 -0.2,0.51 0,0.71l2.79,2.79c0.31,0.31 0.85,0.09 0.85,-0.36L7,19h11c0.55,0 1,-0.45 1,-1v-4c0,-0.55 -0.45,-1 -1,-1s-1,0.45 -1,1v3z" />
+
+</vector>
diff --git a/app/src/main/res/drawable/ic_loop_off.xml b/app/src/main/res/drawable/ic_loop_off.xml
new file mode 100644
index 000000000..553481549
--- /dev/null
+++ b/app/src/main/res/drawable/ic_loop_off.xml
@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:tint="#FFFFFF"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M7,7h10v1.79c0,0.45 0.54,0.67 0.85,0.35l2.79,-2.79c0.2,-0.2 0.2,-0.51 0,-0.71l-2.79,-2.79c-0.31,-0.31 -0.85,-0.09 -0.85,0.36L17,5L6,5c-0.55,0 -1,0.45 -1,1v4c0,0.55 0.45,1 1,1s1,-0.45 1,-1L7,7zM17,17L7,17v-1.79c0,-0.45 -0.54,-0.67 -0.85,-0.35l-2.79,2.79c-0.2,0.2 -0.2,0.51 0,0.71l2.79,2.79c0.31,0.31 0.85,0.09 0.85,-0.36L7,19h11c0.55,0 1,-0.45 1,-1v-4c0,-0.55 -0.45,-1 -1,-1s-1,0.45 -1,1v3z" />
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M2.47,2.47L1.06,3.88l18.12,18.12l1.41,-1.41L2.47,2.47z" />
+</vector>
diff --git a/app/src/main/res/drawable/ic_loop_one.xml b/app/src/main/res/drawable/ic_loop_one.xml
new file mode 100644
index 000000000..43dbc5de7
--- /dev/null
+++ b/app/src/main/res/drawable/ic_loop_one.xml
@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:tint="#FFFFFF"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M7,7h10v1.79c0,0.45 0.54,0.67 0.85,0.35l2.79,-2.79c0.2,-0.2 0.2,-0.51 0,-0.71l-2.79,-2.79c-0.31,-0.31 -0.85,-0.09 -0.85,0.36L17,5L6,5c-0.55,0 -1,0.45 -1,1v4c0,0.55 0.45,1 1,1s1,-0.45 1,-1L7,7zM17,17L7,17v-1.79c0,-0.45 -0.54,-0.67 -0.85,-0.35l-2.79,2.79c-0.2,0.2 -0.2,0.51 0,0.71l2.79,2.79c0.31,0.31 0.85,0.09 0.85,-0.36L7,19h11c0.55,0 1,-0.45 1,-1v-4c0,-0.55 -0.45,-1 -1,-1s-1,0.45 -1,1v3zM13,14.25L13,9.81c0,-0.45 -0.36,-0.81 -0.81,-0.81 -0.13,0 -0.25,0.03 -0.36,0.09l-1.49,0.74c-0.21,0.1 -0.34,0.32 -0.34,0.55 0,0.34 0.28,0.62 0.62,0.62h0.88v3.25c0,0.41 0.34,0.75 0.75,0.75s0.75,-0.34 0.75,-0.75z" />
+</vector>
diff --git a/app/src/main/res/drawable/ic_mute.xml b/app/src/main/res/drawable/ic_mute.xml
new file mode 100644
index 000000000..c026a420c
--- /dev/null
+++ b/app/src/main/res/drawable/ic_mute.xml
@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:tint="#FFFFFF" android:viewportHeight="24"
+    android:viewportWidth="24" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M7,10v4c0,0.55 0.45,1 1,1h3l3.29,3.29c0.63,0.63 1.71,0.18 1.71,-0.71V6.41c0,-0.89 -1.08,-1.34 -1.71,-0.71L11,9H8c-0.55,0 -1,0.45 -1,1z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_pause.xml b/app/src/main/res/drawable/ic_pause.xml
new file mode 100644
index 000000000..5366af34b
--- /dev/null
+++ b/app/src/main/res/drawable/ic_pause.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M8,19c1.1,0 2,-0.9 2,-2L10,7c0,-1.1 -0.9,-2 -2,-2s-2,0.9 -2,2v10c0,1.1 0.9,2 2,2zM14,7v10c0,1.1 0.9,2 2,2s2,-0.9 2,-2L18,7c0,-1.1 -0.9,-2 -2,-2s-2,0.9 -2,2z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_paypal.xml b/app/src/main/res/drawable/ic_paypal.xml
new file mode 100644
index 000000000..64e14e57d
--- /dev/null
+++ b/app/src/main/res/drawable/ic_paypal.xml
@@ -0,0 +1,15 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="48dp"
+    android:height="48dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:fillColor="#FF001C64"
+        android:pathData="M37.97 13.82c0.1-5.56-4.48-9.84-10.8-9.84H14.11c-0.3 0-0.6 0.11-0.83 0.31-0.23 0.2-0.38 0.47-0.43 0.77l-5.23 32.7c-0.02 0.15-0.01 0.3 0.03 0.44 0.04 0.15 0.1 0.28 0.2 0.4 0.1 0.1 0.22 0.2 0.36 0.26 0.14 0.07 0.29 0.1 0.43 0.1h7.74l-1.2 7.57c-0.03 0.15-0.02 0.3 0.02 0.44 0.04 0.15 0.11 0.28 0.2 0.4 0.1 0.11 0.23 0.2 0.36 0.26 0.14 0.07 0.29 0.1 0.44 0.1h6.3c0.3 0 0.58-0.11 0.8-0.3 0.24-0.2 0.28-0.48 0.32-0.78l1.85-10.88c0.05-0.3 0.2-0.7 0.44-0.9 0.23-0.19 0.43-0.3 0.73-0.3h3.86c6.18 0 11.43-4.4 12.39-10.5 0.68-4.35-1.18-8.3-4.92-10.25Z"/>
+    <path
+        android:fillColor="#FF0070E0"
+        android:pathData="M18.06 26.9l-1.93 12.22-1.21 7.66c-0.02 0.15-0.02 0.3 0.03 0.45 0.04 0.14 0.1 0.28 0.2 0.4 0.1 0.1 0.22 0.2 0.36 0.26 0.14 0.06 0.28 0.1 0.44 0.1h6.66c0.3 0 0.6-0.12 0.83-0.31 0.24-0.2 0.39-0.47 0.44-0.77l1.75-11.14c0.05-0.3 0.2-0.58 0.44-0.78 0.23-0.2 0.52-0.3 0.82-0.3h3.93c6.19 0 11.43-4.51 12.39-10.63 0.68-4.33-1.5-8.28-5.24-10.24 0 0.46-0.05 0.92-0.12 1.38-0.96 6.11-6.2 10.62-12.39 10.62h-6.14c-0.3 0-0.6 0.11-0.83 0.3-0.23 0.2-0.39 0.48-0.43 0.78Z"/>
+    <path
+        android:fillColor="#FF003087"
+        android:pathData="M16.13 39.12H8.37c-0.15 0-0.3-0.03-0.44-0.1-0.13-0.06-0.25-0.15-0.35-0.26-0.1-0.12-0.17-0.25-0.21-0.4-0.04-0.14-0.05-0.3-0.03-0.44l5.23-33.18c0.05-0.3 0.2-0.58 0.44-0.77 0.23-0.2 0.52-0.31 0.83-0.31h13.33c6.32 0 10.9 4.6 10.8 10.16-1.57-0.82-3.41-1.3-5.44-1.3H21.41c-0.3 0-0.6 0.11-0.83 0.31-0.23 0.2-0.38 0.47-0.43 0.77l-2.1 13.3-1.92 12.22Z"/>
+</vector>
\ No newline at end of file
diff --git a/app/src/main/res/drawable/ic_pip.xml b/app/src/main/res/drawable/ic_pip.xml
new file mode 100644
index 000000000..f132fecbc
--- /dev/null
+++ b/app/src/main/res/drawable/ic_pip.xml
@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M120,440Q103,440 91.5,428.5Q80,417 80,400Q80,383 91.5,371.5Q103,360 120,360L224,360L80,217Q68,205 68,188.5Q68,172 80,160Q92,148 108.5,148Q125,148 137,160L280,304L280,200Q280,183 291.5,171.5Q303,160 320,160Q337,160 348.5,171.5Q360,183 360,200L360,400Q360,417 348.5,428.5Q337,440 320,440L120,440ZM160,800Q127,800 103.5,776.5Q80,753 80,720L80,560Q80,543 91.5,531.5Q103,520 120,520Q137,520 148.5,531.5Q160,543 160,560L160,720Q160,720 160,720Q160,720 160,720L440,720Q457,720 468.5,731.5Q480,743 480,760Q480,777 468.5,788.5Q457,800 440,800L160,800ZM840,520Q823,520 811.5,508.5Q800,497 800,480L800,240Q800,240 800,240Q800,240 800,240L480,240Q463,240 451.5,228.5Q440,217 440,200Q440,183 451.5,171.5Q463,160 480,160L800,160Q833,160 856.5,183.5Q880,207 880,240L880,480Q880,497 868.5,508.5Q857,520 840,520ZM600,800Q583,800 571.5,788.5Q560,777 560,760L560,640Q560,623 571.5,611.5Q583,600 600,600L840,600Q857,600 868.5,611.5Q880,623 880,640L880,760Q880,777 868.5,788.5Q857,800 840,800L600,800Z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_play.xml b/app/src/main/res/drawable/ic_play.xml
new file mode 100644
index 000000000..12ddceab5
--- /dev/null
+++ b/app/src/main/res/drawable/ic_play.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M8,6.82v10.36c0,0.79 0.87,1.27 1.54,0.84l8.14,-5.18c0.62,-0.39 0.62,-1.29 0,-1.69L9.54,5.98C8.87,5.55 8,6.03 8,6.82z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_playlist.xml b/app/src/main/res/drawable/ic_playlist.xml
new file mode 100644
index 000000000..e16a396f2
--- /dev/null
+++ b/app/src/main/res/drawable/ic_playlist.xml
@@ -0,0 +1,5 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:autoMirrored="true" android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24" android:viewportWidth="24" android:width="24dp">
+      
+    <path android:fillColor="@android:color/white" android:pathData="M5,10h10c0.55,0 1,0.45 1,1s-0.45,1 -1,1L5,12c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1zM5,6h10c0.55,0 1,0.45 1,1s-0.45,1 -1,1L5,8c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1zM5,14h6c0.55,0 1,0.45 1,1s-0.45,1 -1,1L5,16c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1zM14,14.88v4.23c0,0.39 0.42,0.63 0.76,0.43l3.53,-2.12c0.32,-0.19 0.32,-0.66 0,-0.86l-3.53,-2.12c-0.34,-0.19 -0.76,0.05 -0.76,0.44z"/>
+    
+</vector>
diff --git a/app/src/main/res/drawable/ic_portrait.xml b/app/src/main/res/drawable/ic_portrait.xml
new file mode 100644
index 000000000..683c4ba6a
--- /dev/null
+++ b/app/src/main/res/drawable/ic_portrait.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M17,1.01L7,1c-1.1,0 -1.99,0.9 -1.99,2v18c0,1.1 0.89,2 1.99,2h10c1.1,0 2,-0.9 2,-2V3c0,-1.1 -0.9,-1.99 -2,-1.99zM17,19H7V5h10v14z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_remove.xml b/app/src/main/res/drawable/ic_remove.xml
new file mode 100644
index 000000000..90b8308fb
--- /dev/null
+++ b/app/src/main/res/drawable/ic_remove.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M18,13H6c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1h12c0.55,0 1,0.45 1,1s-0.45,1 -1,1z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_reset.xml b/app/src/main/res/drawable/ic_reset.xml
new file mode 100644
index 000000000..2fff9eafb
--- /dev/null
+++ b/app/src/main/res/drawable/ic_reset.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M13.26,3C8.17,2.86 4,6.95 4,12L2.21,12c-0.45,0 -0.67,0.54 -0.35,0.85l2.79,2.8c0.2,0.2 0.51,0.2 0.71,0l2.79,-2.8c0.31,-0.31 0.09,-0.85 -0.36,-0.85L6,12c0,-3.9 3.18,-7.05 7.1,-7 3.72,0.05 6.85,3.18 6.9,6.9 0.05,3.91 -3.1,7.1 -7,7.1 -1.61,0 -3.1,-0.55 -4.28,-1.48 -0.4,-0.31 -0.96,-0.28 -1.32,0.08 -0.42,0.42 -0.39,1.13 0.08,1.49C9,20.29 10.91,21 13,21c5.05,0 9.14,-4.17 9,-9.26 -0.13,-4.69 -4.05,-8.61 -8.74,-8.74zM12.75,8c-0.41,0 -0.75,0.34 -0.75,0.75v3.68c0,0.35 0.19,0.68 0.49,0.86l3.12,1.85c0.36,0.21 0.82,0.09 1.03,-0.26 0.21,-0.36 0.09,-0.82 -0.26,-1.03l-2.88,-1.71v-3.4c0,-0.4 -0.34,-0.74 -0.75,-0.74z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_screen_rotation.xml b/app/src/main/res/drawable/ic_screen_rotation.xml
new file mode 100644
index 000000000..dde6912ca
--- /dev/null
+++ b/app/src/main/res/drawable/ic_screen_rotation.xml
@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="14dp"
+    android:height="14dp"
+    android:tint="#FFFFFF"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M10.23,1.75c-0.59,-0.59 -1.54,-0.59 -2.12,0L1.75,8.11c-0.59,0.59 -0.59,1.54 0,2.12l12.02,12.02c0.59,0.59 1.54,0.59 2.12,0l6.36,-6.36c0.59,-0.59 0.59,-1.54 0,-2.12L10.23,1.75zM14.12,20.48L3.52,9.88c-0.39,-0.39 -0.39,-1.02 0,-1.41l4.95,-4.95c0.39,-0.39 1.02,-0.39 1.41,0l10.61,10.61c0.39,0.39 0.39,1.02 0,1.41l-4.95,4.95c-0.39,0.38 -1.03,0.38 -1.42,-0.01zM17.61,1.4C16.04,0.57 14.06,-0.03 11.81,0.02c-0.18,0 -0.26,0.22 -0.14,0.35l3.48,3.48 1.33,-1.33c3.09,1.46 5.34,4.37 5.89,7.86 0.06,0.41 0.44,0.69 0.86,0.62 0.41,-0.06 0.69,-0.45 0.62,-0.86 -0.6,-3.8 -2.96,-7 -6.24,-8.74zM8.85,20.16l-1.33,1.33c-3.09,-1.46 -5.34,-4.37 -5.89,-7.86 -0.06,-0.41 -0.44,-0.69 -0.86,-0.62 -0.41,0.06 -0.69,0.45 -0.62,0.86 0.6,3.81 2.96,7.01 6.24,8.75 1.57,0.83 3.55,1.43 5.8,1.38 0.18,0 0.26,-0.22 0.14,-0.35l-3.48,-3.49z" />
+</vector>
diff --git a/app/src/main/res/drawable/ic_screen_rotation_alt.xml b/app/src/main/res/drawable/ic_screen_rotation_alt.xml
new file mode 100644
index 000000000..a9f195723
--- /dev/null
+++ b/app/src/main/res/drawable/ic_screen_rotation_alt.xml
@@ -0,0 +1,13 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="20dp"
+    android:height="20dp"
+    android:tint="#FFFFFF"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M18.53,9.29C19.16,9.92 18.71,11 17.82,11c-0.27,0 -0.52,-0.11 -0.71,-0.29L10.4,4L5.41,9H7c0.55,0 1,0.45 1,1s-0.45,1 -1,1H3c-0.55,0 -1,-0.45 -1,-1V6c0,-0.55 0.45,-1 1,-1s1,0.45 1,1v1.59l5,-5c0.78,-0.78 2.05,-0.78 2.83,0L18.53,9.29z" />
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M5.47,14.71C4.84,14.08 5.29,13 6.18,13c0.27,0 0.52,0.11 0.71,0.29L13.6,20l4.99,-5H17c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1h4c0.55,0 1,0.45 1,1v4c0,0.55 -0.45,1 -1,1s-1,-0.45 -1,-1v-1.59l-5,5c-0.78,0.78 -2.05,0.78 -2.83,0L5.47,14.71z" />
+</vector>
diff --git a/app/src/main/res/drawable/ic_shuffle.xml b/app/src/main/res/drawable/ic_shuffle.xml
new file mode 100644
index 000000000..628228ffb
--- /dev/null
+++ b/app/src/main/res/drawable/ic_shuffle.xml
@@ -0,0 +1,5 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24" android:viewportWidth="24" android:width="24dp">
+      
+    <path android:fillColor="@android:color/white" android:pathData="M10.59,9.17L6.12,4.7c-0.39,-0.39 -1.02,-0.39 -1.41,0 -0.39,0.39 -0.39,1.02 0,1.41l4.46,4.46 1.42,-1.4zM15.35,4.85l1.19,1.19L4.7,17.88c-0.39,0.39 -0.39,1.02 0,1.41 0.39,0.39 1.02,0.39 1.41,0L17.96,7.46l1.19,1.19c0.31,0.31 0.85,0.09 0.85,-0.36L20,4.5c0,-0.28 -0.22,-0.5 -0.5,-0.5h-3.79c-0.45,0 -0.67,0.54 -0.36,0.85zM14.83,13.41l-1.41,1.41 3.13,3.13 -1.2,1.2c-0.31,0.31 -0.09,0.85 0.36,0.85h3.79c0.28,0 0.5,-0.22 0.5,-0.5v-3.79c0,-0.45 -0.54,-0.67 -0.85,-0.35l-1.19,1.19 -3.13,-3.14z"/>
+    
+</vector>
diff --git a/app/src/main/res/drawable/ic_shuffle_on.xml b/app/src/main/res/drawable/ic_shuffle_on.xml
new file mode 100644
index 000000000..1880e0def
--- /dev/null
+++ b/app/src/main/res/drawable/ic_shuffle_on.xml
@@ -0,0 +1,5 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24" android:viewportWidth="24" android:width="24dp">
+      
+    <path android:fillColor="@android:color/white" android:pathData="M21,1H3C1.9,1 1,1.9 1,3v18c0,1.1 0.9,2 2,2h18c1.1,0 2,-0.9 2,-2V3C23,1.9 22.1,1 21,1zM4.3,4.7c0.39,-0.39 1.02,-0.39 1.41,0l4.47,4.47l-1.42,1.4L4.3,6.11C3.91,5.72 3.91,5.09 4.3,4.7zM19.59,19.5c0,0.28 -0.22,0.5 -0.5,0.5H15.3c-0.45,0 -0.67,-0.54 -0.36,-0.85l1.2,-1.2l-3.13,-3.13l1.41,-1.41l3.13,3.14l1.19,-1.19c0.31,-0.32 0.85,-0.1 0.85,0.35V19.5zM19.59,8.29c0,0.45 -0.54,0.67 -0.85,0.36l-1.19,-1.19L5.7,19.29c-0.39,0.39 -1.02,0.39 -1.41,0c-0.39,-0.39 -0.39,-1.02 0,-1.41L16.13,6.04l-1.19,-1.19C14.63,4.54 14.85,4 15.3,4h3.79c0.28,0 0.5,0.22 0.5,0.5V8.29z"/>
+    
+</vector>
diff --git a/app/src/main/res/drawable/ic_skip_next.xml b/app/src/main/res/drawable/ic_skip_next.xml
new file mode 100644
index 000000000..93c89da63
--- /dev/null
+++ b/app/src/main/res/drawable/ic_skip_next.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M7.58,16.89l5.77,-4.07c0.56,-0.4 0.56,-1.24 0,-1.63L7.58,7.11C6.91,6.65 6,7.12 6,7.93v8.14c0,0.81 0.91,1.28 1.58,0.82zM16,7v10c0,0.55 0.45,1 1,1s1,-0.45 1,-1V7c0,-0.55 -0.45,-1 -1,-1s-1,0.45 -1,1z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_skip_prev.xml b/app/src/main/res/drawable/ic_skip_prev.xml
new file mode 100644
index 000000000..aec0051ce
--- /dev/null
+++ b/app/src/main/res/drawable/ic_skip_prev.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M7,6c0.55,0 1,0.45 1,1v10c0,0.55 -0.45,1 -1,1s-1,-0.45 -1,-1L6,7c0,-0.55 0.45,-1 1,-1zM10.66,12.82l5.77,4.07c0.66,0.47 1.58,-0.01 1.58,-0.82L18.01,7.93c0,-0.81 -0.91,-1.28 -1.58,-0.82l-5.77,4.07c-0.57,0.4 -0.57,1.24 0,1.64z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_sleep_timer.xml b/app/src/main/res/drawable/ic_sleep_timer.xml
new file mode 100644
index 000000000..d271b7f11
--- /dev/null
+++ b/app/src/main/res/drawable/ic_sleep_timer.xml
@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24"
+    android:tint="?attr/colorControlNormal">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M15,1H9v2h6V1zM11,14h2V8h-2v6zM19.03,7.39l1.42,-1.42c-0.43,-0.51 -0.9,-0.99 -1.41,-1.41l-1.42,1.42C16.07,4.74 14.12,4 12,4c-4.97,0 -9,4.03 -9,9s4.03,9 9,9 9,-4.03 9,-9c0,-2.12 -0.74,-4.07 -1.97,-5.61zM12,20c-3.87,0 -7,-3.13 -7,-7s3.13,-7 7,-7 7,3.13 7,7 -3.13,7 -7,7z" />
+</vector>
diff --git a/app/src/main/res/drawable/ic_speed.xml b/app/src/main/res/drawable/ic_speed.xml
new file mode 100644
index 000000000..446997ad3
--- /dev/null
+++ b/app/src/main/res/drawable/ic_speed.xml
@@ -0,0 +1,6 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M20.39,8.56l-1.24,1.86a8,8 0,0 1,-0.22 7.58H5.07A8,8 0,0 1,15.58 6.85l1.86,-1.24A10,10 0,0 0,4 20h16a10,10 0,0 0,0.38 -11.44z"/>
+    <path android:fillColor="@android:color/white" android:pathData="M10.59,15.41a2,2 0,0 0,2.83 0l5.66,-8.49 -8.49,5.66a2,2 0,0 0,0 2.83z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_subtitle_track.xml b/app/src/main/res/drawable/ic_subtitle_track.xml
new file mode 100644
index 000000000..ab65b524f
--- /dev/null
+++ b/app/src/main/res/drawable/ic_subtitle_track.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M20,4L4,4c-1.1,0 -2,0.9 -2,2v12c0,1.1 0.9,2 2,2h16c1.1,0 2,-0.9 2,-2L22,6c0,-1.1 -0.9,-2 -2,-2zM5,12h2c0.55,0 1,0.45 1,1s-0.45,1 -1,1L5,14c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1zM13,18L5,18c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1h8c0.55,0 1,0.45 1,1s-0.45,1 -1,1zM19,18h-2c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1h2c0.55,0 1,0.45 1,1s-0.45,1 -1,1zM19,14h-8c-0.55,0 -1,-0.45 -1,-1s0.45,-1 1,-1h8c0.55,0 1,0.45 1,1s-0.45,1 -1,1z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_upi.xml b/app/src/main/res/drawable/ic_upi.xml
new file mode 100644
index 000000000..0a4eac690
--- /dev/null
+++ b/app/src/main/res/drawable/ic_upi.xml
@@ -0,0 +1,14 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="64dp"
+    android:height="64dp"
+    android:viewportWidth="64"
+    android:viewportHeight="64">
+    <path
+        android:fillColor="#FF097939"
+        android:fillType="evenOdd"
+        android:pathData="M55.05 32.54L38.72 0 20.57 64l34.48-31.46Z"/>
+    <path
+        android:fillColor="#FFED752E"
+        android:fillType="evenOdd"
+        android:pathData="M43.43 32.54L27.1 0 8.95 64l34.48-31.46Z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_volume.xml b/app/src/main/res/drawable/ic_volume.xml
new file mode 100644
index 000000000..e01ac3c2d
--- /dev/null
+++ b/app/src/main/res/drawable/ic_volume.xml
@@ -0,0 +1,5 @@
+<vector android:autoMirrored="true" android:height="24dp"
+    android:tint="#FFFFFF" android:viewportHeight="24"
+    android:viewportWidth="24" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M3,10v4c0,0.55 0.45,1 1,1h3l3.29,3.29c0.63,0.63 1.71,0.18 1.71,-0.71L12,6.41c0,-0.89 -1.08,-1.34 -1.71,-0.71L7,9L4,9c-0.55,0 -1,0.45 -1,1zM16.5,12c0,-1.77 -1.02,-3.29 -2.5,-4.03v8.05c1.48,-0.73 2.5,-2.25 2.5,-4.02zM14,4.45v0.2c0,0.38 0.25,0.71 0.6,0.85C17.18,6.53 19,9.06 19,12s-1.82,5.47 -4.4,6.5c-0.36,0.14 -0.6,0.47 -0.6,0.85v0.2c0,0.63 0.63,1.07 1.21,0.85C18.6,19.11 21,15.84 21,12s-2.4,-7.11 -5.79,-8.4c-0.58,-0.23 -1.21,0.22 -1.21,0.85z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_width_wide.xml b/app/src/main/res/drawable/ic_width_wide.xml
new file mode 100644
index 000000000..f41b20e24
--- /dev/null
+++ b/app/src/main/res/drawable/ic_width_wide.xml
@@ -0,0 +1,5 @@
+<vector android:height="24dp" android:tint="#FFFFFF"
+    android:viewportHeight="24" android:viewportWidth="24"
+    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="@android:color/white" android:pathData="M20,4H4C2.9,4 2,4.9 2,6v12c0,1.1 0.9,2 2,2h16c1.1,0 2,-0.9 2,-2V6C22,4.9 21.1,4 20,4zM4,6h2v12H4V6zM20,18h-2V6h2V18z"/>
+</vector>
diff --git a/app/src/main/res/drawable/overlay_background.xml b/app/src/main/res/drawable/overlay_background.xml
new file mode 100644
index 000000000..cba199833
--- /dev/null
+++ b/app/src/main/res/drawable/overlay_background.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <solid android:color="@color/player_background" />
+    <corners android:radius="8dp" />
+</shape>
\ No newline at end of file
diff --git a/app/src/main/res/drawable/progress_scale_drawable.xml b/app/src/main/res/drawable/progress_scale_drawable.xml
new file mode 100644
index 000000000..21cefb981
--- /dev/null
+++ b/app/src/main/res/drawable/progress_scale_drawable.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <item android:id="@android:id/background">
+        <shape >
+            <solid android:color="@color/transparent_white_300"/>
+            <corners android:radius="100dp"/>
+        </shape>
+    </item>
+
+    <item android:id="@android:id/progress">
+        <scale android:scaleGravity="bottom" android:scaleWidth="0%" android:scaleHeight="100%">
+            <shape >
+                <solid android:color="@android:color/white"/>
+                <corners android:radius="100dp"/>
+            </shape>
+        </scale>
+    </item>
+</layer-list>
\ No newline at end of file
diff --git a/app/src/main/res/drawable/rounded_corner.xml b/app/src/main/res/drawable/rounded_corner.xml
new file mode 100644
index 000000000..81cc83bcd
--- /dev/null
+++ b/app/src/main/res/drawable/rounded_corner.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="?attr/colorControlHighlight">
+    <item android:id="@android:id/mask">
+        <shape android:shape="oval">
+            <solid android:color="@android:color/white" />
+        </shape>
+    </item>
+    <item>
+        <shape>
+            <solid android:color="@color/player_background" />
+            <corners android:radius="10000dp" />
+        </shape>
+    </item>
+</ripple>
\ No newline at end of file
diff --git a/app/src/main/res/drawable/transparent_circle_background.xml b/app/src/main/res/drawable/transparent_circle_background.xml
new file mode 100644
index 000000000..f0f8b6111
--- /dev/null
+++ b/app/src/main/res/drawable/transparent_circle_background.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@android:color/white">
+    <item android:id="@android:id/mask">
+        <shape android:shape="oval">
+            <solid android:color="@android:color/white" />
+        </shape>
+    </item>
+    <item>
+        <shape>
+            <solid android:color="@android:color/transparent" />
+        </shape>
+    </item>
+</ripple>
diff --git a/app/src/main/res/values/arrays_exoplayer.xml b/app/src/main/res/values/arrays_exoplayer.xml
new file mode 100644
index 000000000..b553de6f2
--- /dev/null
+++ b/app/src/main/res/values/arrays_exoplayer.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string-array name="charsets_list">
+        <item>Auto (Automatic)</item>
+        <item>UTF-8 (UTF-8)</item>
+        <item>UTF-16 (UTF-16)</item>
+        <item>UTF-16BE (UTF-16BE)</item>
+        <item>UTF-16LE (UTF-16LE)</item>
+        <item>US-ASCII (US-ASCII)</item>
+        <item>ISO-8859-1 (ISO-8859-1)</item>
+        <item>ISO-8859-2 (ISO-8859-2)</item>
+        <item>ISO-8859-5 (ISO-8859-5)</item>
+        <item>ISO-8859-6 (ISO-8859-6)</item>
+        <item>ISO-8859-7 (ISO-8859-7)</item>
+        <item>ISO-8859-8 (ISO-8859-8)</item>
+        <item>ISO-8859-9 (ISO-8859-9)</item>
+        <item>Windows-1250 (Windows-1250)</item>
+        <item>Windows-1251 (Windows-1251)</item>
+        <item>Windows-1252 (Windows-1252)</item>
+        <item>Windows-1253 (Windows-1253)</item>
+        <item>Windows-1254 (Windows-1254)</item>
+        <item>Windows-1255 (Windows-1255)</item>
+        <item>Windows-1256 (Windows-1256)</item>
+        <item>Shift_JIS (Shift_JIS)</item>
+        <item>EUC-JP (EUC-JP)</item>
+        <item>ISO-2022-JP (ISO-2022-JP)</item>
+        <item>GBK (GBK)</item>
+        <item>GB18030 (GB18030)</item>
+        <item>Big5 (Big5)</item>
+        <item>EUC-KR (EUC-KR)</item>
+    </string-array>
+</resources>
diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml
new file mode 100644
index 000000000..02e668821
--- /dev/null
+++ b/app/src/main/res/values/colors.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="player_background">#4D000000</color>
+    <color name="transparent_white_300">#4DFFFFFF</color>
+</resources>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 261cd94a6..05a18b583 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -814,4 +814,476 @@
   <string name="pref_ytdl_prefer_h264_title">Prefer H.264 (AVC)</string>
   <string name="pref_ytdl_prefer_h264_summary">Increases compatibility on older devices but may limit quality</string>
   <string name="pref_ytdl_quality_title">Preferred Quality</string>
+
+  <!-- Ported from One-Player -->
+  <string name="about_description">Version and device info</string>
+  <string name="about_name">About</string>
+  <string name="appearance_name">Appearance</string>
+  <string name="appearance_and_general_name">Appearance &amp; general</string>
+  <string name="ascending">Ascending</string>
+  <string name="descending">Descending</string>
+  <string name="disable">Disable</string>
+  <string name="double_tap">Double tap gesture</string>
+  <string name="double_tap_description">Select double tap gesture action</string>
+  <string name="error_playing_video">Error: Can\'t play video</string>
+  <string name="fast_seek">Fast seeking</string>
+  <string name="fast_seek_description">Seek to nearest key frame instead of exact one.</string>
+  <string name="grant_permission">Grant Permission</string>
+  <string name="group_videos">Group videos by folder</string>
+  <string name="duration">Duration</string>
+  <string name="location">Location</string>
+  <string name="menu">Menu</string>
+  <string name="navigate_up">Navigate up</string>
+  <string name="no_videos_found">No videos found</string>
+  <string name="open_settings">Open Settings</string>
+  <string name="permission_info">The Only Player app needs \"%1$s\" permission to access and play media. Without it, media access and playback won\'t work. To use the app fully, grant the permission.</string>
+  <string name="permission_not_granted">Permission Not Granted</string>
+  <string name="permission_request">Permission Request</string>
+  <string name="permission_settings">The Only Player app needs \"%1$s\" permission to access and play media. Without it, media access and playback won\'t work. To use the app fully, grant the permission from settings since it was permanently denied.</string>
+  <string name="player_controls_exit">Back</string>
+  <string name="player_controls_next">Player next</string>
+  <string name="player_controls_play_pause">Player play pause</string>
+  <string name="player_controls_previous">Player previous</string>
+  <string name="player_controls_progress">Player progress bar</string>
+  <string name="player_description">Player appearance, playback controls</string>
+  <string name="player_name">Player</string>
+  <string name="gestures_name">Gestures</string>
+  <string name="gestures_description">Configure player touch gestures</string>
+  <string name="quick_settings">Quick Settings</string>
+  <string name="autoplay_settings">Autoplay</string>
+  <string name="autoplay_settings_description">Automatically play the next video in the current folder</string>
+  <string name="pip_settings">Picture in Picture Mode</string>
+  <string name="pip_settings_description">Automatically switch to miniature player when tapping Home Button</string>
+  <string name="remember_brightness_level">Remember brightness level</string>
+  <string name="remember_brightness_level_description">Remember brightness level between playback sessions</string>
+  <string name="remember_selections">Remember selections</string>
+  <string name="remember_selections_description">Remember selections for each file like audio track, subtitle track, etc.</string>
+  <string name="resume">Resume</string>
+  <string name="resume_description">Select whether to resume played videos from the point where you stopped</string>
+  <string name="seek_gesture">Seek gesture</string>
+  <string name="seek_gesture_description">Swipe horizontally to seek forwards or backwards</string>
+  <string name="select_audio_track">Select audio track</string>
+  <string name="select_subtitle_track">Select subtitle track</string>
+  <string name="unknown_error">An unknown error has occurred</string>
+  <string name="playback">Playback</string>
+  <string name="playback_behavior">Playback behavior</string>
+  <string name="video_processing">Video processing</string>
+  <string name="video_filters">Video filters</string>
+  <string name="enable_video_filters">Enable video filters</string>
+  <string name="enable_video_filters_description">Turn this off to skip GPU video filtering and save battery</string>
+  <string name="video_filters_unavailable_software_decoder">The software decoder does not support video filters</string>
+  <string name="video_filters_default">Default</string>
+  <string name="video_filters_adjusted_count">%1$d adjusted</string>
+  <string name="interface_name">Interface</string>
+  <string name="a_z">A-Z</string>
+  <string name="z_a">Z-A</string>
+  <string name="shortest">Shortest</string>
+  <string name="longest">Longest</string>
+  <string name="smallest">Smallest</string>
+  <string name="largest">Largest</string>
+  <string name="theme_mode">Theme mode</string>
+  <string name="follow_system_theme">Follow system</string>
+  <string name="light_theme">Light theme</string>
+  <string name="dark_theme">Dark theme</string>
+  <string name="video_zoom">Video zoom</string>
+  <string name="dynamic_theme">Dynamic color theme</string>
+  <string name="dynamic_theme_description">Apply colors from system wallpaper to the application theme</string>
+  <string name="controls_lock">Lock controls</string>
+  <string name="controls_unlock">Unlock controls</string>
+  <string name="select_playback_speed">Select playback speed</string>
+  <string name="exo_audio">Audio</string>
+  <string name="audio_track_settings">Audio track</string>
+  <string name="audio_focus_and_devices">Audio focus &amp; devices</string>
+  <string name="volume_memory">Volume memory</string>
+  <string name="volume_processing">Volume processing</string>
+  <string name="preferred_audio_lang">Preferred audio language</string>
+  <string name="preferred_audio_lang_description">Language of the audio track you want to use by default</string>
+  <string name="subtitle">Subtitle</string>
+  <string name="subtitle_loading">Subtitle loading</string>
+  <string name="subtitle_style_source">Style source</string>
+  <string name="subtitle_font_settings">Font</string>
+  <string name="subtitle_appearance">Subtitle appearance</string>
+  <string name="subtitle_auto_load">Auto-load subtitles</string>
+  <string name="subtitle_auto_load_desc">Automatically select subtitle track when playing video</string>
+  <string name="preferred_subtitle_lang">Preferred subtitle language</string>
+  <string name="preferred_subtitle_lang_description">Language of the subtitle track you want to use by default</string>
+  <string name="system_default">System Default</string>
+  <string name="off">Off</string>
+  <string name="on">On</string>
+  <string name="play_pause">Play/Pause</string>
+  <string name="ff_rewind">Fast forward/Rewind</string>
+  <string name="play_pause_ff_rewind">Play/Pause and Fast forward/Rewind</string>
+  <string name="auto">Auto</string>
+  <string name="enable">Enable</string>
+  <string name="yes">Yes</string>
+  <string name="no">No</string>
+  <string name="scan">Scan</string>
+  <string name="media_library">Media library</string>
+  <string name="force_rescan_storage">Force rescan storage</string>
+  <string name="force_rescan_storage_desc">Caution: Initiating a full storage rescan may cause increased resource usage on your device</string>
+  <string name="media_library_description">Scan and manage media library</string>
+  <string name="scanning_storage">Scanning storage…</string>
+  <string name="manage_folders">Manage folders</string>
+  <string name="ignore_nomedia_files">Ignore .nomedia files</string>
+  <string name="ignore_nomedia_files_desc">Show videos inside directories that contain a .nomedia file, including their subdirectories. Requires all files access.</string>
+  <string name="manage_folders_desc">Select folders to be excluded in the media library</string>
+  <string name="video">Video</string>
+  <string name="videos">Videos</string>
+  <string name="screen_rotation">Screen Rotation</string>
+  <string name="player_screen_orientation">Player screen orientation</string>
+  <string name="automatic">Automatic (sensor)</string>
+  <string name="landscape">Landscape</string>
+  <string name="landscape_reverse">Landscape reverse</string>
+  <string name="landscape_auto">Landscape (sensor)</string>
+  <string name="portrait">Portrait</string>
+  <string name="video_orientation">Video Orientation</string>
+  <string name="ambience_mode">Ambience mode</string>
+  <string name="remember_player_screen_orientation">Remember rotation</string>
+  <string name="remember_player_screen_orientation_description">Start playback with the last manually selected rotation</string>
+  <string name="newest">Newest</string>
+  <string name="oldest">Oldest</string>
+  <string name="date">Date</string>
+  <string name="default_playback_speed">Default playback speed</string>
+  <string name="enter_a_network_url">Enter a network URL:</string>
+  <string name="network_stream">Network Stream</string>
+  <string name="play_file">Open video file to play</string>
+  <string name="play_url">Enter video url to play</string>
+  <string name="default_name">Default</string>
+  <string name="monospace">Monospace</string>
+  <string name="sans_serif">Sans Serif</string>
+  <string name="serif">Serif</string>
+  <string name="subtitle_font">Subtitle font</string>
+  <string name="external_subtitle_font_import">Import external subtitle font</string>
+  <string name="external_subtitle_font_import_desc">Import one .ttf or .otf file for plain text subtitles</string>
+  <string name="external_subtitle_font_current">Current imported font</string>
+  <string name="external_subtitle_font_not_imported">Not imported</string>
+  <string name="external_subtitle_font_clear">Clear imported subtitle font</string>
+  <string name="external_subtitle_font_clear_desc">Remove the current imported subtitle font and use built-in fonts again</string>
+  <string name="external_subtitle_font_notice_title">External subtitle font notice</string>
+  <string name="external_subtitle_font_system_style_notice">Imported subtitle fonts do not take effect while system caption style is enabled</string>
+  <string name="external_subtitle_font_import_success">Subtitle font imported</string>
+  <string name="external_subtitle_font_import_failed">Failed to import subtitle font</string>
+  <string name="external_subtitle_font_clear_success">Imported subtitle font cleared</string>
+  <string name="subtitle_text_bold">Bold subtitle text</string>
+  <string name="subtitle_text_bold_desc">Use bold text for subtitle</string>
+  <string name="subtitle_text_size">Subtitle text size</string>
+  <string name="reset_subtitle_text_size">Reset subtitle text size</string>
+  <string name="subtitle_position">Subtitle vertical position</string>
+  <string name="reset_subtitle_position">Reset subtitle vertical position</string>
+  <string name="subtitle_desc">Subtitle appearance, playback options</string>
+  <string name="subtitle_background">Subtitle background</string>
+  <string name="subtitle_background_desc">Enable background to subtitle text</string>
+  <string name="subtitle_text_color">Subtitle text color</string>
+  <string name="subtitle_color_white">White</string>
+  <string name="subtitle_color_yellow">Yellow</string>
+  <string name="subtitle_color_cyan">Cyan</string>
+  <string name="subtitle_color_green">Green</string>
+  <string name="subtitle_edge_style">Subtitle edge style</string>
+  <string name="subtitle_edge_none">None</string>
+  <string name="subtitle_edge_outline">Outline</string>
+  <string name="subtitle_edge_shadow">Drop shadow</string>
+  <string name="decoder">Decoder</string>
+  <string name="decoder_desc">Decoder priority and video filter options</string>
+  <string name="video_software_decoders">Software video decoders</string>
+  <string name="video_software_decoders_desc">Use application software video decoders (experimental)</string>
+  <string name="decoder_priority">Decoder</string>
+  <string name="auto_hw_decoder">Auto detect (prefer hardware decoding)</string>
+  <string name="auto_hw_plus_decoder">Auto detect (prefer hardware decoding+)</string>
+  <string name="hw_decoder">Hardware decoding</string>
+  <string name="hw_plus_decoder">Hardware decoding+</string>
+  <string name="sw_decoder">Software decoding</string>
+  <string name="prefer_device_decoders">Prefer device decoders</string>
+  <string name="prefer_app_decoders">Prefer app decoders</string>
+  <string name="device_decoders_only">Device decoders only</string>
+  <string name="embedded_styles">Embedded styles</string>
+  <string name="embedded_styles_desc">Apply the embedded styles that are present in subtitle files, such as ASS and so on</string>
+  <string name="controller_timeout">Controller timeout</string>
+  <string name="seek_increment">Seek increment</string>
+  <string name="delete_file">The following file will be deleted permanently</string>
+  <string name="subtitle_text_encoding">Subtitle text encoding</string>
+  <string name="fast_playback_speed">%.1fx speed</string>
+  <string name="long_press_gesture">Long press gesture</string>
+  <string name="long_press_gesture_desc">Long press to play at %.1fx speed</string>
+  <string name="long_press_variable_speed">Real-time long press speed</string>
+  <string name="long_press_variable_speed_desc">Swipe left or right while holding to adjust temporary speed</string>
+  <string name="best_fit">Best fit</string>
+  <string name="stretch">Stretch</string>
+  <string name="hundred_percent">100%</string>
+  <string name="video_brightness">Brightness</string>
+  <string name="video_contrast">Contrast</string>
+  <string name="video_saturation">Saturation</string>
+  <string name="video_hue">Hue</string>
+  <string name="video_gamma">Gamma</string>
+  <string name="video_sharpening">Video sharpening</string>
+  <string name="reset_video_brightness">Reset video brightness</string>
+  <string name="reset_video_contrast">Reset video contrast</string>
+  <string name="reset_video_saturation">Reset video saturation</string>
+  <string name="reset_video_hue">Reset video hue</string>
+  <string name="reset_video_gamma">Reset video gamma</string>
+  <string name="reset_video_sharpening">Reset video sharpening</string>
+  <string name="zoom_gesture">Zoom gesture</string>
+  <string name="zoom_gesture_description">Pinch to zoom the video</string>
+  <string name="audio_desc">Audio playback options</string>
+  <string name="pause_on_headset_disconnect">Pause on disconnect</string>
+  <string name="pause_on_headset_disconnect_desc">Pause playback when headset disconnected from the device</string>
+  <string name="system_volume_panel">System volume panel</string>
+  <string name="system_volume_panel_desc">Show system volume panel while adjusting volume with headset on</string>
+  <string name="remember_volume_level">Remember volume level</string>
+  <string name="remember_volume_level_description">Restore the player volume level when playback starts</string>
+  <string name="initial_volume_limit">Initial volume limit</string>
+  <string name="reset_initial_volume_limit">Reset initial volume limit</string>
+  <string name="volume_normalization">Volume normalization</string>
+  <string name="volume_normalization_desc">Reduce volume swings with dynamic range processing</string>
+  <string name="system_caption_style">System caption style</string>
+  <string name="system_caption_style_desc">Click to open system captioning preferences</string>
+  <string name="fields">Fields</string>
+  <string name="extension">Extension</string>
+  <string name="path">Path</string>
+  <string name="resolution">Resolution</string>
+  <string name="require_audio_focus">Require audio focus</string>
+  <string name="require_audio_focus_desc">Pause other players while this player is playing videos, and vice versa.</string>
+  <string name="format">Format</string>
+  <string name="video_track">Video Track</string>
+  <string name="audio_track">Audio Track</string>
+  <string name="subtitle_track">Subtitle Track</string>
+  <string name="codec">Codec</string>
+  <string name="sample_rate">Sample rate</string>
+  <string name="sample_format">Sample format</string>
+  <string name="bitrate">Bitrate</string>
+  <string name="channels">Channels</string>
+  <string name="language">Language</string>
+  <string name="frame_rate">Frame rate</string>
+  <string name="properties">Properties</string>
+  <string name="volume_boost">Volume boost</string>
+  <string name="volume_boost_desc">Boost audio volume up to 200%</string>
+  <string name="open_subtitle">Open local subtitle</string>
+  <string name="add_online_subtitle">Add online subtitle</string>
+  <string name="online_subtitle_url">Subtitle URL</string>
+  <string name="online_subtitle_add">Add</string>
+  <string name="online_subtitle_added">Online subtitle added</string>
+  <string name="online_subtitle_unsupported_url">Unsupported subtitle URL</string>
+  <string name="online_subtitle_too_large">Online subtitle is too large (max 10MB)</string>
+  <string name="online_subtitle_empty">Online subtitle is empty</string>
+  <string name="online_subtitle_download_failed">Failed to download online subtitle</string>
+  <string name="local_subtitle_unsupported">Unsupported subtitle file</string>
+  <string name="no_subtitle_tracks_found">Subtitle tracks for this video are either unavailable or not supported.</string>
+  <string name="no_audio_tracks_found">Audio tracks for this video are either unavailable or not supported.</string>
+  <string name="rename_to">Rename to</string>
+  <string name="mark_last_played_media">Mark last played media</string>
+  <string name="mark_last_played_media_desc">Mark last played media in home and in each folder</string>
+  <string name="restore_last_played_media_in_folders">Auto-locate last video</string>
+  <string name="restore_last_played_media_in_folders_desc">Scroll to the last played item when opening a folder</string>
+  <string name="recycle_bin">Recycle bin</string>
+  <string name="recycle_bin_desc">Keep deleted items available until you remove them permanently. When enabled, the recycle bin entry appears in the home top bar.</string>
+  <string name="open_local_video">Open local video</string>
+  <string name="open_network_stream">Open network stream</string>
+  <string name="play_next_video">Play next video</string>
+  <string name="skip_silence">Skip silence</string>
+  <string name="played_progress">Played progress</string>
+  <string name="media_view_mode">Media view mode</string>
+  <string name="enable_pip_from_settings">Picture-in-Picture is disabled. Enable it in Settings to use this feature.</string>
+  <string name="control_buttons_alignment_left">Left</string>
+  <string name="control_buttons_alignment_right">Right</string>
+  <string name="control_buttons_alignment">Control buttons alignment</string>
+  <string name="player_control_labels">Hide control labels</string>
+  <string name="player_control_labels_description">Hide text under player control buttons</string>
+  <string name="player_controls">Player controls</string>
+  <string name="stop_player_session">Stop player session</string>
+  <string name="background_play">Background play</string>
+  <string name="background_play_description">Play in background when tapped on home or screen is locked.</string>
+  <string name="loop_mode">Loop mode</string>
+  <string name="loop_mode_off">Loop: Off</string>
+  <string name="loop_mode_one">Loop: One</string>
+  <string name="loop_mode_all">Loop: All</string>
+  <string name="libraries">Libraries</string>
+  <string name="diagnostics">Diagnostics</string>
+  <string name="app_logs">App logs</string>
+  <string name="app_logs_description">View, copy, clear, and export logs stored in the app private directory</string>
+  <string name="share_logs">Share logs</string>
+  <string name="copy_logs">Copy logs</string>
+  <string name="clear_logs">Clear logs</string>
+  <string name="no_logs">No logs yet</string>
+  <string name="logs_copied">Logs copied</string>
+  <string name="logs_cleared">Logs cleared</string>
+  <string name="logs_share_failed">Failed to share logs</string>
+  <string name="device_info">Device info</string>
+  <string name="architecture">Architecture</string>
+  <string name="android_version">Android version</string>
+  <string name="error_opening_link">No app found to handle this link</string>
+  <string name="all_files_access_title">Allow all files access</string>
+  <string name="all_files_access_message">This app needs all files access to scan videos in folders hidden by .nomedia and keep the media library complete.</string>
+  <string name="media_library_all_files_access_desc">Ignore .nomedia files and recycle bin require all files access. Grant permission to enable both features.</string>
+  <string name="go_to_settings">Go to settings</string>
+  <string name="not_now">Not now</string>
+  <string name="media_layout">Media Layout</string>
+  <string name="media_layout_scale">Layout scale</string>
+  <string name="media_layout_scale_decrease">Decrease</string>
+  <string name="media_layout_scale_increase">Increase</string>
+  <string name="media_layout_scale_reset">Reset scale</string>
+  <string name="recently_played">Recently played</string>
+  <string name="delete_one_video">Delete 1 video?</string>
+  <string name="delete_videos">Delete %1$d videos?</string>
+  <string name="delete_one_folder">Delete 1 folder?</string>
+  <string name="delete_folders">Delete %1$d folders?</string>
+  <string name="delete_items">Delete %1$d items?</string>
+  <string name="delete_item_info">This action cannot be undone. The selected item will be permanently deleted</string>
+  <string name="delete_items_info">This action cannot be undone. The selected items will be permanently deleted</string>
+  <string name="swipe_gestures">Swipe gestures</string>
+  <string name="tap_gestures">Tap gestures</string>
+  <string name="long_press_gestures">Long press gestures</string>
+  <string name="zoom_and_pan_gestures">Zoom and pan</string>
+  <string name="other_gestures">Other gestures</string>
+  <string name="volume_gesture">Volume gesture</string>
+  <string name="volume_gesture_description">Adjust volume by swiping vertically</string>
+  <string name="brightness_gesture">Brightness gesture</string>
+  <string name="brightness_gesture_description">Adjust brightness by swiping vertically</string>
+  <string name="pan_gesture">Pan gesture</string>
+  <string name="pan_gesture_description">Zoom and pan the video</string>
+  <string name="m_n_selected">%1$d / %2$d Selected</string>
+  <string name="reset_seek_increment">Reset seek increment</string>
+  <string name="reset_controller_timeout">Reset controller timeout</string>
+  <string name="reset_default_playback_speed">Reset default playback speed</string>
+  <string name="seek_gesture_sensitivity">Seek gesture sensitivity</string>
+  <string name="reset_seek_sensitivity">Reset seek sensitivity</string>
+  <string name="seek_sensitivity">Seek sensitivity</string>
+  <string name="reset_seek_sentivity">Reset seek sensitivity</string>
+  <string name="player_icon_style">Player icon style</string>
+  <string name="player_icon_style_tonal">Tonal</string>
+  <string name="player_icon_style_classic">Classic</string>
+  <string name="player_icon_style_translucent">Translucent</string>
+  <string name="player_icon_style_legacy_only">Only applies to the legacy controls layout</string>
+  <string name="player_controls_style">Controls layout</string>
+  <string name="player_controls_style_description">Switch between the legacy controls and the modern menu-based layout</string>
+  <string name="player_controls_style_legacy">Legacy</string>
+  <string name="player_controls_style_modern">Modern</string>
+  <string name="volume_gesture_sensitivity">Volume gesture sensitivity</string>
+  <string name="reset_volume_gesture_sensitivity">Reset volume gesture sensitivity</string>
+  <string name="brightness_gesture_sensitivity">Brightness gesture sensitivity</string>
+  <string name="reset_brightness_gesture_sensitivity">Reset brightness gesture sensitivity</string>
+  <string name="shuffle">Shuffle</string>
+  <string name="sleep_timer_off">Off</string>
+  <string name="sleep_timer_minutes">%d min</string>
+  <string name="sleep_timer_remaining">Remaining</string>
+  <string name="privacy_protection">Privacy protection</string>
+  <string name="privacy_protection_description">Prevent screenshots and hide app content in recents</string>
+  <string name="prevent_screenshots">Prevent screenshots</string>
+  <string name="prevent_screenshots_description">Block screenshots and screen recording inside the app</string>
+  <string name="hide_in_recents">Hide content in recents</string>
+  <string name="hide_in_recents_description">Hide app preview in the recent tasks screen</string>
+  <string name="general_description">User data options</string>
+  <string name="user_data">User data</string>
+  <string name="delete_video_cache">Delete video cache</string>
+  <string name="delete_video_cache_description">Delete cached thumbnails, media list snapshots, subtitles, and MKV seek data</string>
+  <string name="delete_video_cache_confirmation">Are you sure you want to delete all video cache?</string>
+  <string name="reset_settings">Reset settings</string>
+  <string name="reset_settings_description">Reset all settings to their default state</string>
+  <string name="reset_settings_confirmation">Are you sure you want to reset all settings to their default state?</string>
+  <string name="delay">Delay</string>
+  <string name="search_videos_and_folders">Search videos and folders</string>
+  <string name="recent_searches">Recent searches</string>
+  <string name="popular_folders">Popular folders</string>
+  <string name="clear_history">Clear history</string>
+  <string name="no_results_found">No results found</string>
+  <string name="search_results">Search results</string>
+  <string name="now_playing">Now playing</string>
+  <string name="no_videos_in_queue">No videos in queue</string>
+  <string name="reorder">Reorder</string>
+  <string name="remove">Remove</string>
+  <string name="first_frame">First frame</string>
+  <string name="first_frame_desc">Use the first frame of the video</string>
+  <string name="frame_at_position">Frame at position</string>
+  <string name="frame_at_position_desc">Use frame at specific position in the video</string>
+  <string name="hybrid">Hybrid (smart)</string>
+  <string name="hybrid_desc">Attempts to use the first frame. If it\'s mostly a solid color, uses a frame from at specific position in the video instead</string>
+  <string name="hybrid_slow">Slower</string>
+  <string name="frame_position">Frame position</string>
+  <string name="frame_position_value">Frame at %1$.0f%% of the video duration</string>
+  <string name="thumbnail_setting_change_confirmation">Changing this setting will clear the thumbnail cache. Thumbnails will be generated again when media list is opened. Continue?</string>
+  <string name="app_language">App language</string>
+  <string name="app_language_description">Choose the language used across the app</string>
+  <string name="backup_settings">Backup settings</string>
+  <string name="backup_settings_description">Save app and player preferences to a file</string>
+  <string name="restore_settings">Restore settings</string>
+  <string name="restore_settings_description">Import app and player preferences from a backup file</string>
+  <string name="backup_settings_success">Settings backed up</string>
+  <string name="backup_settings_failed">Failed to back up settings</string>
+  <string name="restore_settings_success">Settings restored</string>
+  <string name="restore_settings_failed">Failed to restore settings</string>
+  <string name="move_to_recycle_bin">Move to recycle bin</string>
+  <string name="move_to_recycle_bin_info">The selected items will be moved to recycle bin</string>
+  <string name="move">Move</string>
+  <string name="move_here">Move here</string>
+  <string name="moving">Moving…</string>
+  <string name="move_success">Moved %1$d items</string>
+  <string name="move_failed">Move failed</string>
+  <string name="move_partial_success">Moved %1$d items, %2$d failed</string>
+  <string name="move_cancelled">Canceled, moved %1$d items, %2$d failed</string>
+  <string name="move_progress_title">Moving</string>
+  <string name="move_progress_message">Processed %1$d/%2$d items</string>
+  <string name="cancel_remaining_move">Cancel remaining</string>
+  <string name="continue_move">Continue</string>
+  <string name="delete_permanently">Delete permanently</string>
+  <string name="settings_backup_file_name">onlyplayer-settings.json</string>
+  <string name="exclude">Exclude</string>
+  <string name="update_check">Update</string>
+  <string name="check_for_updates">Check for updates</string>
+  <string name="check_updates_on_startup">Check on startup</string>
+  <string name="check_updates_on_startup_desc">Automatically check for updates when opening this page</string>
+  <string name="update_status_idle">Tap to check for the latest version</string>
+  <string name="update_status_checking">Checking…</string>
+  <string name="update_status_up_to_date">Already up to date</string>
+  <string name="update_status_available">New version %1$s available, tap to view</string>
+  <string name="update_status_error">Check failed, tap to retry</string>
+  <string name="update_dialog_title">Update available</string>
+  <string name="update_dialog_message">Version %1$s is available. Do you want to view the update now?</string>
+  <string name="update_dialog_confirm">View update</string>
+  <string name="tab_local">Local</string>
+  <string name="tab_cloud">Cloud</string>
+  <string name="tab_settings">Settings</string>
+  <string name="cloud_servers">Cloud servers</string>
+  <string name="no_servers_configured">No configuration</string>
+  <string name="add_server">Add server</string>
+  <string name="edit_server">Edit server</string>
+  <string name="delete_server">Delete server</string>
+  <string name="delete_server_confirmation">Are you sure you want to delete "%1$s"?</string>
+  <string name="server_name">Server name</string>
+  <string name="server_protocol">Protocol</string>
+  <string name="server_host">Host</string>
+  <string name="server_port">Port</string>
+  <string name="server_path">Path</string>
+  <string name="server_username">Username</string>
+  <string name="server_password">Password</string>
+  <string name="proxy_settings">Proxy</string>
+  <string name="proxy_host">Proxy host</string>
+  <string name="proxy_port">Proxy port</string>
+  <string name="proxy_enabled">Enable proxy</string>
+  <string name="browsing">Browsing</string>
+  <string name="connection_failed">Connection failed</string>
+  <string name="connecting">Connecting…</string>
+  <string name="empty_directory">Empty directory</string>
+  <string name="parent_directory">Parent directory</string>
+  <string name="home_title_long_press_to_root">Long press title to go home</string>
+  <string name="home_title_long_press_to_root_description">Long press the title bar to navigate back to the root folder</string>
+  <string name="take_screenshot">Take screenshot</string>
+  <string name="screenshot_saved">Screenshot saved to Pictures/Screenshots</string>
+  <string name="screenshot_failed">Failed to save screenshot</string>
+  <string name="customize_player_controls">Customize controls</string>
+    <string name="exo_thumbnail">Thumbnail</string>
+    <string name="exo_thumbnail_generation">Thumbnail generation</string>
+    <string name="exo_gestures">Gestures</string>
+    <string name="exo_seconds">%1$s seconds</string>
+    <string name="exo_degrees">%1$d°</string>
+    <string name="exo_percent">%1$d%%</string>
+    <string name="exo_general_name">General</string>
+    <string name="exo_sleep_timer">Sleep timer</string>
+    <string name="exo_unknown">Unknown</string>
+    <string name="exo_done">Done</string>
+    <string name="exo_cancel">Cancel</string>
+    <string name="exo_exit">Exit</string>
+    <string name="exo_speed">Speed</string>
+    <string name="exo_subtitle">Subtitle</string>
+    <string name="exo_decoder">Decoder</string>
+    <string name="exo_player">Player</string>
+    <string name="exo_media_library">Media library</string>
+    <string name="exo_appearance">Appearance</string>
 </resources>
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 9f560847c..9227650b4 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -12,10 +12,14 @@ nanohttpd = "2.3.1"
 room = "2.8.4"
 navigation3 = "1.1.1"
 kotlinx-serialization = "1.11.0"
+kotlinx-coroutines = "1.11.0"
 kotlinx-collections-immutable = "0.4.0"
+
 truetype-parser = "2.1.4"
 accompanist = "0.37.3"
+libassAndroid = "0.4.0"
 okhttp = "5.3.2"
+
 jsoup = "1.22.2"
 sardineAndroid = "0.9"
 reorderable = "3.1.0"
@@ -26,8 +30,11 @@ androidxConstraintLayout = "2.2.1"
 coil = "3.4.0"
 media3 = "1.10.0"
 soraEditor = "0.24.5"
+androidxDataStore = "1.2.1"
 androidxMaterial3 = "1.5.0-alpha19"
+
 androidxAppcompat = "1.7.1"
+androidxMedia3 = "1.10.1"
 composeConstraintLayout = "1.1.1"
 androidxMedia = "1.8.0"
 androidxDocumentfile = "1.1.0"
@@ -35,8 +42,10 @@ composePrefs = "2.2.0"
 desugarJdkLibs = "2.1.5"
 fsaf = "1.1.3"
 materialSymbols = "2.2.1"
+universalChardet = "2.5.0"
 seeker = "2.0.1"
 
+
 [libraries]
 androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
 androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
@@ -49,6 +58,7 @@ androidx-ui = { group = "androidx.compose.ui", name = "ui" }
 androidx-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
 androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
 androidx-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+androidx-compose-material-icons-extended = { group = "androidx.compose.material", name = "material-icons-extended" }
 androidx-material3-android = { group = "androidx.compose.material3", name = "material3", version.ref = "androidxMaterial3" }
 androidx-compose-material = { group = "androidx.compose.material", name = "material" }
 androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "androidxAppcompat" }
@@ -63,16 +73,31 @@ androidx-documentfile = { group = "androidx.documentfile", name = "documentfile"
 seeker = { module = "com.github.abdallahmehiz:seeker", version.ref = "seeker" }
 mediainfo-lib = "com.github.marlboro-advance:mediainfoAndroid:v1.0.0-fix"
 
+androidx-media3-common = { module = "androidx.media3:media3-common", version.ref = "androidxMedia3" }
+androidx-media3-datasource-okhttp = { module = "androidx.media3:media3-datasource-okhttp", version.ref = "androidxMedia3" }
+androidx-media3-effect = { module = "androidx.media3:media3-effect", version.ref = "androidxMedia3" }
+androidx-media3-exoplayer = { module = "androidx.media3:media3-exoplayer", version.ref = "androidxMedia3" }
+androidx-media3-exoplayer-dash = { module = "androidx.media3:media3-exoplayer-dash", version.ref = "androidxMedia3" }
+androidx-media3-exoplayer-hls = { module = "androidx.media3:media3-exoplayer-hls", version.ref = "androidxMedia3" }
+androidx-media3-exoplayer-rtsp = { module = "androidx.media3:media3-exoplayer-rtsp", version.ref = "androidxMedia3" }
+androidx-media3-session = { module = "androidx.media3:media3-session", version.ref = "androidxMedia3" }
+androidx-media3-ui = { module = "androidx.media3:media3-ui", version.ref = "androidxMedia3" }
+androidx-media3-ui-compose = { module = "androidx.media3:media3-ui-compose", version.ref = "androidxMedia3" }
+androidx-media3-transformer = { module = "androidx.media3:media3-transformer", version.ref = "androidxMedia3" }
+
+
+juniversalchardet = { module = "com.github.albfernandez:juniversalchardet", version.ref = "universalChardet" }
 google-material = { module = "com.google.android.material:material", version.ref = "googleMaterial" }
+
+androidx-datastore-preferences = { group = "androidx.datastore", name = "datastore-preferences", version.ref = "androidxDataStore" }
+androidx-datastore-core = { group = "androidx.datastore", name = "datastore", version.ref = "androidxDataStore" }
 androidx-core-ktx = { module = "androidx.core:core-ktx", version.ref = "androidxCore" }
+
 androidx-preference-ktx = { module = "androidx.preference:preference-ktx", version.ref = "androidxPreference" }
 androidx-constraintlayout = { module = "androidx.constraintlayout:constraintlayout", version.ref = "androidxConstraintLayout" }
 coil = { module = "io.coil-kt.coil3:coil", version.ref = "coil" }
 coil-compose = { module = "io.coil-kt.coil3:coil-compose", version.ref = "coil" }
 coil-network-okhttp = { module = "io.coil-kt.coil3:coil-network-okhttp", version.ref = "coil" }
-androidx-media3-common = { module = "androidx.media3:media3-common", version.ref = "media3" }
-androidx-media3-effect = { module = "androidx.media3:media3-effect", version.ref = "media3" }
-androidx-media3-transformer = { module = "androidx.media3:media3-transformer", version.ref = "media3" }
 sora-editor-bom = { module = "io.github.rosemoe:editor-bom", version.ref = "soraEditor" }
 sora-editor = { module = "io.github.rosemoe:editor" }
 sora-language-textmate = { module = "io.github.rosemoe:language-textmate" }
@@ -91,14 +116,18 @@ room-compiler = { module = "androidx.room:room-compiler", version.ref = "room" }
 room-ktx = { module = "androidx.room:room-ktx", version.ref = "room" }
 
 kotlinx-immutable-collections = { module = "org.jetbrains.kotlinx:kotlinx-collections-immutable", version.ref = "kotlinx-collections-immutable" }
+kotlinx-coroutines-guava = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-guava", version.ref = "kotlinx-coroutines" }
 kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
 
+
 truetype-parser = { module = "io.github.yubyf:truetypeparser-light", version.ref = "truetype-parser" }
 fsaf = { module = "com.github.K1rakishou:Fuck-Storage-Access-Framework", version.ref = "fsaf" }
 accompanist-permissions = { module = "com.google.accompanist:accompanist-permissions", version.ref = "accompanist" }
 desugar-jdk-libs = { module = "com.android.tools:desugar_jdk_libs", version.ref = "desugarJdkLibs" }
 
+ass-media = { module = "io.github.peerless2012:ass-media", version.ref = "libassAndroid" }
 okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
+
 jsoup = { module = "org.jsoup:jsoup", version.ref = "jsoup" }
 reorderable = { module = "sh.calvin.reorderable:reorderable", version.ref = "reorderable" }