StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
Fix hardware-only decoder recovery and update 1.2.3 changelog
David Nashash0fb4879bedbd
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.mdindex 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.ktindex 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 nullif (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 nullif (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 thisdiff --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.ktindex 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 = playerRecoveryExecutionPortdiff --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.ktindex 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.PlayerErrorimport kotlinx.coroutines.test.advanceUntilIdleimport kotlinx.coroutines.test.runTestimport org.junit.Test+import org.mockito.kotlin.anyimport org.mockito.kotlin.mockimport org.mockito.kotlin.neverimport 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.ktindex 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.SOFTWAREelse -> 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 falseval mediaId = lastMediaId ?: return falseval fallbackMode = videoDecoderPreferencePolicy.onDecoderInitFailure(requestedVideoDecoderMode, mediaId) ?: return falseval 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.ktindex 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.Localeenum 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: Booleanget() = 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 -> 0ActiveDecoderPolicy.HARDWARE_PREFERRED -> if (isSoftwareCodec(info.name)) 1 else 0ActiveDecoderPolicy.SOFTWARE_PREFERRED,ActiveDecoderPolicy.COMPATIBILITY -> if (isSoftwareCodec(info.name)) 0 else 1diff --git a/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt b/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.ktindex 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)+ }+@Testfun `software codec names are recognized`() {assertThat(PlaybackCodecSelector.isSoftwareCodec("OMX.google.h264.decoder")).isTrue()