Skip to content

StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.

Fix hardware-only decoder recovery and update 1.2.3 changelog

David Nashash0fb4879bedbd
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 6a05eb7f..7afd5cc1 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -18,6 +18,7 @@ All notable product changes are recorded in this document.
- VOD timelines can now be scrubbed with the D-pad in 10-second steps; holding a direction previews repeated seeks, and releasing applies the selected position.
### Fixed
+- Fixed Hardware Only video decoding being overridden after live TV stalls; recovery now preserves explicit audio and video decoder settings and excludes software video decoders in Hardware Only mode.
- Fixed channel numbers appearing in Guide Favorites views and selected-channel details when Live TV numbering is set to Hidden.
- Fixed external subtitles disappearing after playback retries or when replaying a movie: attached subtitles are restored with the rebuilt source, and downloaded OpenSubtitles files are kept in durable app storage and remembered for that movie.
- Fixed the player showing a generic recording error when Android alarm access is missing; it now explains how to enable access and retry.
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinator.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinator.kt
index e8d4af38..a2c3b909 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinator.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinator.kt
@@ -30,6 +30,8 @@ internal data class PlayerRecoveryRequest(
val isCatchUp: Boolean,
val currentProgramHasArchive: Boolean,
val livePlaybackReady: Boolean,
+ val requestedAudioDecoderMode: DecoderMode = DecoderMode.AUTO,
+ val requestedVideoDecoderMode: DecoderMode = DecoderMode.AUTO,
)
internal interface PlayerRecoveryExecutionPort {
@@ -95,6 +97,13 @@ class PlayerRecoveryExecutionCoordinator @Inject constructor() {
if (!port.isActivePlaybackSession(request.requestVersion, request.playbackUrl)) return null
if (request.contentType == ContentType.SERIES_EPISODE && port.handleEpisodeReplacementError(error)) return null
+ // The engine deliberately keeps deferred live stalls on the current source.
+ // Calling play() here would undo that decision and reopen a provider connection.
+ if (error is PlayerError.DecoderError && error.isDeferredLiveStall &&
+ request.contentType == ContentType.LIVE && !request.isCatchUp &&
+ request.resolvedStreamInfo?.playbackContentKind != PlaybackContentKind.CATCH_UP
+ ) return null
+
if (error is PlayerError.DecoderError && !port.recoveryState.retriedWithSoftwareDecoder) {
if (!port.isActivePlaybackSession(request.requestVersion, request.playbackUrl)) return null
if (request.contentType == ContentType.LIVE) {
@@ -118,25 +127,31 @@ class PlayerRecoveryExecutionCoordinator @Inject constructor() {
return null
}
}
- port.recoveryState.retriedWithSoftwareDecoder = true
- logWarning("Decoder error detected. Retrying with software decoder mode.")
- port.playerEngine.setDecoderModes(
- audioMode = DecoderMode.SOFTWARE,
- videoMode = DecoderMode.SOFTWARE
- )
- port.updateDecoderModes(
- audioMode = DecoderMode.SOFTWARE,
- videoMode = DecoderMode.SOFTWARE
- )
- port.setLastFailureReason(error.message)
- port.appendRecoveryAction("Switched to software decoder")
- port.playerEngine.play()
- port.showPlayerNotice(
- message = "Retrying with software decoding for this stream.",
- recoveryType = PlayerRecoveryType.DECODER,
- actions = port.buildRecoveryActions(PlayerRecoveryType.DECODER)
- )
- return null
+ if (request.requestedAudioDecoderMode == DecoderMode.AUTO ||
+ request.requestedVideoDecoderMode == DecoderMode.AUTO
+ ) {
+ val audioMode = request.requestedAudioDecoderMode.softwareRecoveryMode()
+ val videoMode = request.requestedVideoDecoderMode.softwareRecoveryMode()
+ port.recoveryState.retriedWithSoftwareDecoder = true
+ logWarning("Decoder error detected. Retrying with software decoder mode.")
+ port.playerEngine.setDecoderModes(
+ audioMode = audioMode,
+ videoMode = videoMode
+ )
+ port.updateDecoderModes(
+ audioMode = audioMode,
+ videoMode = videoMode
+ )
+ port.setLastFailureReason(error.message)
+ port.appendRecoveryAction("Switched to software decoder")
+ port.playerEngine.play()
+ port.showPlayerNotice(
+ message = "Retrying with software decoding for this stream.",
+ recoveryType = PlayerRecoveryType.DECODER,
+ actions = port.buildRecoveryActions(PlayerRecoveryType.DECODER)
+ )
+ return null
+ }
}
port.recordMovieVariantFailureObservation(error)
@@ -316,3 +331,6 @@ private fun PlayerRecoveryRequest.isLiveHlsSession(): Boolean {
return listOfNotNull(streamInfo?.url, currentStreamUrl, playbackUrl)
.any { url -> StreamTypeResolver.resolve(url = url, isLive = true) == ResolvedStreamType.HLS }
}
+
+private fun DecoderMode.softwareRecoveryMode(): DecoderMode =
+ if (this == DecoderMode.AUTO) DecoderMode.SOFTWARE else this
diff --git a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt
index 9df21dd3..6026f9b3 100644
--- a/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt
+++ b/feature/playback/src/main/java/com/streamvault/feature/playback/player/PlayerViewModel.kt
@@ -1042,7 +1042,9 @@ class PlayerViewModel @Inject constructor(
channel = currentChannelFlow.value?.sanitizedForPlayer(),
isCatchUp = isCatchUpPlayback(),
currentProgramHasArchive = currentProgram.value?.hasArchive == true,
- livePlaybackReady = livePlaybackReadyForCurrentSession
+ livePlaybackReady = livePlaybackReadyForCurrentSession,
+ requestedAudioDecoderMode = preferredAudioDecoderMode,
+ requestedVideoDecoderMode = preferredVideoDecoderMode
),
sessionScope = playbackSessionScope(requestVersion),
port = playerRecoveryExecutionPort
diff --git a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinatorTest.kt b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinatorTest.kt
index 5fc62f76..c0702dae 100644
--- a/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinatorTest.kt
+++ b/feature/playback/src/test/java/com/streamvault/feature/playback/player/PlayerRecoveryExecutionCoordinatorTest.kt
@@ -12,6 +12,7 @@ import com.streamvault.player.PlayerError
import kotlinx.coroutines.test.advanceUntilIdle
import kotlinx.coroutines.test.runTest
import org.junit.Test
+import org.mockito.kotlin.any
import org.mockito.kotlin.mock
import org.mockito.kotlin.never
import org.mockito.kotlin.verify
@@ -74,8 +75,7 @@ class PlayerRecoveryExecutionCoordinatorTest {
coordinator.handlePlaybackError(liveHlsError, this, port)
advanceUntilIdle()
- assertThat(port.alternateStreamCalls).isEqualTo(1)
- assertThat(port.lastAllowXtreamTsFallback).isFalse()
+ assertThat(port.alternateStreamCalls).isEqualTo(0)
assertThat(port.recoveryState.retriedWithSoftwareDecoder).isFalse()
assertThat(port.notices).isEmpty()
verify(port.playerEngine, never()).setDecoderModes(DecoderMode.SOFTWARE, DecoderMode.SOFTWARE)
@@ -209,6 +209,53 @@ class PlayerRecoveryExecutionCoordinatorTest {
assertThat(port.episodeFallbackCalls).isEqualTo(0)
}
+ @Test
+ fun `TS deferred live stall preserves explicit hardware video and software audio`() = runTest {
+ val port = RecordingRecoveryPort()
+ val failure = request(PlayerError.DecoderError(
+ "Video playback stalled. Automatic recovery was not attempted to avoid opening another provider connection."
+ )).copy(
+ contentType = ContentType.LIVE,
+ resolvedStreamInfo = StreamInfo(url = "https://example.test/live/1.ts", streamType = StreamType.MPEG_TS),
+ channel = Channel(id = 1L, name = "TS channel"),
+ requestedAudioDecoderMode = DecoderMode.SOFTWARE,
+ requestedVideoDecoderMode = DecoderMode.HARDWARE,
+ livePlaybackReady = true
+ )
+ PlayerRecoveryExecutionCoordinator().handlePlaybackError(failure, this, port)
+ advanceUntilIdle()
+ assertThat(port.recoveryState.retriedWithSoftwareDecoder).isFalse()
+ assertThat(port.notices).isEmpty()
+ verify(port.playerEngine, never()).setDecoderModes(any(), any())
+ verify(port.playerEngine, never()).play()
+ }
+
+ @Test
+ fun `audio recovery cannot override explicit hardware video`() = runTest {
+ val port = RecordingRecoveryPort()
+ val failure = request(PlayerError.DecoderError("decoder failed")).copy(
+ requestedVideoDecoderMode = DecoderMode.HARDWARE
+ )
+ PlayerRecoveryExecutionCoordinator().handlePlaybackError(failure, this, port)
+ advanceUntilIdle()
+ verify(port.playerEngine).setDecoderModes(DecoderMode.SOFTWARE, DecoderMode.HARDWARE)
+ verify(port.playerEngine).play()
+ }
+
+ @Test
+ fun `explicit modes cannot be overwritten by decoder recovery`() = runTest {
+ val port = RecordingRecoveryPort()
+ val failure = request(PlayerError.DecoderError("decoder failed")).copy(
+ requestedAudioDecoderMode = DecoderMode.SOFTWARE,
+ requestedVideoDecoderMode = DecoderMode.HARDWARE
+ )
+ PlayerRecoveryExecutionCoordinator().handlePlaybackError(failure, this, port)
+ advanceUntilIdle()
+ verify(port.playerEngine, never()).setDecoderModes(any(), any())
+ verify(port.playerEngine, never()).play()
+ assertThat(port.recoveryState.retriedWithSoftwareDecoder).isFalse()
+ }
+
private fun request(error: PlayerError) = PlayerRecoveryRequest(
error = error,
requestVersion = 1L,
diff --git a/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt b/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
index 29326cd7..d86a767e 100644
--- a/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
+++ b/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
@@ -1579,14 +1579,18 @@ class Media3PlayerEngine @Inject constructor(
learnedAudioCompatibility?.decision == AudioCompatibilityMemoryStore.DECISION_SOFTWARE_FFMPEG -> DecoderMode.SOFTWARE
else -> audioDecoderPreferencePolicy.preferredMode(requestedAudioDecoderMode, mediaId)
}
- val preferredVideoDecoderMode = recoveryVideoDecoderModeOverride ?: videoDecoderPreferencePolicy.preferredMode(
+ val preferredVideoDecoderMode = if (requestedVideoDecoderMode == DecoderMode.HARDWARE) {
+ DecoderMode.HARDWARE
+ } else recoveryVideoDecoderModeOverride ?: videoDecoderPreferencePolicy.preferredMode(
requestedVideoDecoderMode,
mediaId
)
val nextAudioDecoderPolicy = recoveryAudioDecoderPolicyOverride ?: resolveActiveDecoderPolicy(
policyModeFor(requestedAudioDecoderMode, preferredAudioDecoderMode)
)
- val nextVideoDecoderPolicy = recoveryVideoDecoderPolicyOverride ?: resolveActiveDecoderPolicy(
+ val nextVideoDecoderPolicy = if (requestedVideoDecoderMode == DecoderMode.HARDWARE) {
+ ActiveDecoderPolicy.HARDWARE_ONLY
+ } else recoveryVideoDecoderPolicyOverride ?: resolveActiveDecoderPolicy(
policyModeFor(requestedVideoDecoderMode, preferredVideoDecoderMode)
)
compatibilityDecisionSource = when {
@@ -1627,7 +1631,7 @@ class Media3PlayerEngine @Inject constructor(
Log.i(
TAG,
- "prepare resolvedStreamType=$currentResolvedStreamType timeoutProfile=$currentTimeoutProfile audioDecoderPreference=$activeAudioDecoderMode videoDecoderPreference=$activeVideoDecoderMode audioPolicy=$activeAudioDecoderPolicy videoPolicy=$activeVideoDecoderPolicy audioOutputPreference=$audioOutputPreference compatibilitySource=$compatibilityDecisionSource surface=${_renderSurfaceType.value} target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)}"
+ "prepare resolvedStreamType=$currentResolvedStreamType timeoutProfile=$currentTimeoutProfile audioDecoderPreference=$activeAudioDecoderMode videoDecoderPreference=$activeVideoDecoderMode audioPolicy=$activeAudioDecoderPolicy videoPolicy=$activeVideoDecoderPolicy requestedAudioDecoderMode=$requestedAudioDecoderMode requestedVideoDecoderMode=$requestedVideoDecoderMode audioOutputPreference=$audioOutputPreference compatibilitySource=$compatibilityDecisionSource surface=${_renderSurfaceType.value} target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)}"
)
Log.i(TAG, nextBufferPolicy.describeForLog(currentResolvedStreamType, requestedPlaybackBufferMode))
@@ -2720,6 +2724,12 @@ class Media3PlayerEngine @Inject constructor(
seekPositionMs: Long?,
autoPlay: Boolean
): Boolean {
+ if (!shouldAttemptAutomaticRecovery(
+ action = AutomaticRecoveryAction.DECODER_FALLBACK,
+ resolvedStreamType = currentResolvedStreamType,
+ playbackStarted = isEffectivelyPlaybackStarted()
+ )
+ ) return false
val mediaId = lastMediaId ?: return false
val fallbackMode = videoDecoderPreferencePolicy.onDecoderInitFailure(requestedVideoDecoderMode, mediaId) ?: return false
val fallbackPolicy = resolveActiveDecoderPolicy(policyModeFor(requestedVideoDecoderMode, fallbackMode))
@@ -3081,10 +3091,14 @@ class Media3PlayerEngine @Inject constructor(
if (!shouldForceSoftwareForAmbiguousDecoderFallback(audioFallbackMode, videoFallbackMode)) {
return false
}
- recoveryAudioDecoderModeOverride = DecoderMode.SOFTWARE
- recoveryVideoDecoderModeOverride = DecoderMode.SOFTWARE
- recoveryAudioDecoderPolicyOverride = ActiveDecoderPolicy.SOFTWARE_PREFERRED
- recoveryVideoDecoderPolicyOverride = ActiveDecoderPolicy.SOFTWARE_PREFERRED
+ if (audioFallbackMode == DecoderMode.SOFTWARE) {
+ recoveryAudioDecoderModeOverride = DecoderMode.SOFTWARE
+ recoveryAudioDecoderPolicyOverride = ActiveDecoderPolicy.SOFTWARE_PREFERRED
+ }
+ if (videoFallbackMode == DecoderMode.SOFTWARE) {
+ recoveryVideoDecoderModeOverride = DecoderMode.SOFTWARE
+ recoveryVideoDecoderPolicyOverride = ActiveDecoderPolicy.SOFTWARE_PREFERRED
+ }
return true
}
diff --git a/player/src/main/java/com/streamvault/player/playback/CodecPreference.kt b/player/src/main/java/com/streamvault/player/playback/CodecPreference.kt
index 8a52637b..5371f2b5 100644
--- a/player/src/main/java/com/streamvault/player/playback/CodecPreference.kt
+++ b/player/src/main/java/com/streamvault/player/playback/CodecPreference.kt
@@ -13,6 +13,7 @@ import java.util.Locale
enum class ActiveDecoderPolicy {
AUTO,
HARDWARE_PREFERRED,
+ HARDWARE_ONLY,
SOFTWARE_PREFERRED,
COMPATIBILITY
}
@@ -41,7 +42,8 @@ internal data class PlaybackRendererPlan(
val useVideoManagedCodecSelector: Boolean,
val audioExtensionRendererMode: PlaybackExtensionRendererMode,
val videoExtensionRendererMode: PlaybackExtensionRendererMode,
- val renderPath: String
+ val renderPath: String,
+ val hardwareOnlyVideo: Boolean = false
) {
val useManagedCodecSelector: Boolean
get() = useAudioManagedCodecSelector || useVideoManagedCodecSelector
@@ -69,7 +71,10 @@ internal fun buildPlaybackRendererFactorySettings(
plan: PlaybackRendererPlan
): PlaybackRendererFactorySettings = PlaybackRendererFactorySettings(
audioExtensionRendererMode = plan.audioExtensionRendererMode.toMedia3RendererMode(),
- videoExtensionRendererMode = plan.videoExtensionRendererMode.toMedia3RendererMode(),
+ videoExtensionRendererMode = if (plan.hardwareOnlyVideo) {
+ DefaultRenderersFactory.EXTENSION_RENDERER_MODE_OFF
+ } else plan.videoExtensionRendererMode.toMedia3RendererMode(),
+ // Strict hardware video filters the candidate list; another hardware codec is still allowed.
enableDecoderFallback = true
)
@@ -139,7 +144,8 @@ internal fun buildPlaybackRendererPlan(
useVideoManagedCodecSelector = useVideoManagedCodecSelector,
audioExtensionRendererMode = audioExtensionRendererMode,
videoExtensionRendererMode = videoExtensionRendererMode,
- renderPath = renderPath
+ renderPath = renderPath,
+ hardwareOnlyVideo = requestedVideoMode == DecoderMode.HARDWARE
)
}
@@ -157,12 +163,15 @@ class PlaybackCodecSelector(
val infos = delegate.getDecoderInfos(mimeType, requiresSecureDecoder, requiresTunnelingDecoder)
val knownBad = knownBadProvider().map { it.lowercase(Locale.ROOT) }.toSet()
val policy = policyProvider()
- return infos.sortedWith(
+ return infos.filter { info ->
+ policy != ActiveDecoderPolicy.HARDWARE_ONLY ||
+ (info.hardwareAccelerated && !info.softwareOnly && !isSoftwareCodec(info.name))
+ }.sortedWith(
compareBy<MediaCodecInfo> { info ->
if (info.name.lowercase(Locale.ROOT) in knownBad) 1 else 0
}.thenBy { info ->
when (policy) {
- ActiveDecoderPolicy.AUTO -> 0
+ ActiveDecoderPolicy.AUTO, ActiveDecoderPolicy.HARDWARE_ONLY -> 0
ActiveDecoderPolicy.HARDWARE_PREFERRED -> if (isSoftwareCodec(info.name)) 1 else 0
ActiveDecoderPolicy.SOFTWARE_PREFERRED,
ActiveDecoderPolicy.COMPATIBILITY -> if (isSoftwareCodec(info.name)) 0 else 1
diff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt
index 7a60f272..63d7b695 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt
@@ -14,6 +14,54 @@ import org.robolectric.RobolectricTestRunner
@RunWith(RobolectricTestRunner::class)
class PlaybackCodecSelectorTest {
+ @Test
+ fun `strict hardware video excludes software even when hardware is known bad`() {
+ fun codec(name: String, hardware: Boolean) =
+ androidx.media3.exoplayer.mediacodec.MediaCodecInfo.newInstance(
+ name, "video/avc", "video/avc", null, hardware, !hardware, hardware, false, false
+ )
+ val hardware = codec("OMX.amlogic.avc.decoder.awesome2", true)
+ val software = codec("OMX.google.h264.decoder", false)
+ val selector = PlaybackCodecSelector(
+ delegate = androidx.media3.exoplayer.mediacodec.MediaCodecSelector { _, _, _ ->
+ mutableListOf(software, hardware)
+ },
+ policyProvider = { ActiveDecoderPolicy.HARDWARE_ONLY },
+ knownBadProvider = { setOf(hardware.name) }
+ )
+ assertThat(selector.getDecoderInfos("video/avc", false, false)).containsExactly(hardware)
+ }
+
+ @Test
+ fun `strict hardware video cannot use a software only codec list`() {
+ val software = androidx.media3.exoplayer.mediacodec.MediaCodecInfo.newInstance(
+ "OMX.google.h264.decoder", "video/avc", "video/avc", null, false, true, false, false, false
+ )
+ val selector = PlaybackCodecSelector(
+ delegate = androidx.media3.exoplayer.mediacodec.MediaCodecSelector { _, _, _ -> mutableListOf(software) },
+ policyProvider = { ActiveDecoderPolicy.HARDWARE_ONLY },
+ knownBadProvider = { emptySet() }
+ )
+ assertThat(selector.getDecoderInfos("video/avc", false, false)).isEmpty()
+ }
+
+ @Test
+ fun `hardware video disables extensions while software audio remains enabled`() {
+ val plan = buildPlaybackRendererPlan(
+ requestedAudioMode = DecoderMode.SOFTWARE,
+ activeAudioDecoderMode = DecoderMode.SOFTWARE,
+ audioDecoderPolicy = ActiveDecoderPolicy.SOFTWARE_PREFERRED,
+ requestedVideoMode = DecoderMode.HARDWARE,
+ activeVideoDecoderMode = DecoderMode.HARDWARE,
+ videoDecoderPolicy = ActiveDecoderPolicy.HARDWARE_ONLY,
+ useAudioVideoSyncSink = false,
+ useVideoRendererWorkaround = false
+ )
+ val settings = buildPlaybackRendererFactorySettings(plan)
+ assertThat(settings.videoExtensionRendererMode).isEqualTo(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_OFF)
+ assertThat(settings.audioExtensionRendererMode).isEqualTo(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER)
+ }
+
@Test
fun `software codec names are recognized`() {
assertThat(PlaybackCodecSelector.isSoftwareCodec("OMX.google.h264.decoder")).isTrue()