Skip to content

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

fixed ffmpeg decoder issue

David Nashashcc8561df434c
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupport.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupport.kt
index ebcc9c87..5a6be199 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupport.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupport.kt
@@ -8,6 +8,7 @@ internal fun classifyPlaybackError(error: PlayerError): PlayerRecoveryType = whe
PlayerRecoveryType.BUFFER_TIMEOUT
} else if (
error.message.contains("HTTP 456", ignoreCase = true) ||
+ error.message.contains("HTTP 509", ignoreCase = true) ||
error.message.contains("access denied", ignoreCase = true) ||
error.message.contains("temporary link", ignoreCase = true) ||
error.message.contains("playback path", ignoreCase = true)
@@ -37,6 +38,9 @@ internal fun resolvePlaybackErrorMessage(error: PlayerError): String = when (cla
error.message.contains("access denied", ignoreCase = true) ->
"This provider rejected playback for this channel. The MAC or subscription may not have access to this stream."
+ error.message.contains("HTTP 509", ignoreCase = true) ->
+ "Provider rejected playback, likely max connections or bandwidth limit."
+
error.message.contains("temporary link", ignoreCase = true) ->
"This portal issued an empty or invalid temporary link for playback."
diff --git a/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupportTest.kt b/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupportTest.kt
new file mode 100644
index 00000000..5e7c7fc4
--- /dev/null
+++ b/app/src/test/java/com/streamvault/app/ui/screens/player/PlayerPlaybackRecoverySupportTest.kt
@@ -0,0 +1,19 @@
+package com.streamvault.app.ui.screens.player
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.player.PlayerError
+import org.junit.Test
+
+class PlayerPlaybackRecoverySupportTest {
+
+ @Test
+ fun `509 source error shows provider limit message`() {
+ val error = PlayerError.SourceError(
+ "Provider rejected playback, likely max connections or bandwidth limit (HTTP 509)."
+ )
+
+ assertThat(classifyPlaybackError(error)).isEqualTo(PlayerRecoveryType.SOURCE)
+ assertThat(resolvePlaybackErrorMessage(error))
+ .isEqualTo("Provider rejected playback, likely max connections or bandwidth limit.")
+ }
+}
diff --git a/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt b/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
index 2ba8b71c..37e94e67 100644
--- a/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
+++ b/player/src/main/java/com/streamvault/player/Media3PlayerEngine.kt
@@ -46,11 +46,10 @@ import com.streamvault.player.playback.PlaybackCodecSelector
import com.streamvault.player.playback.PlaybackCompatibilityProfile
import com.streamvault.player.playback.PlaybackBufferPolicies
import com.streamvault.player.playback.PlaybackErrorCategory
-import com.streamvault.player.playback.FfmpegAudioFallbackRequest
import com.streamvault.player.playback.FfmpegExtensionSupport
+import com.streamvault.player.playback.PlaybackExtensionRendererMode
import com.streamvault.player.playback.PlaybackLogSanitizer
import com.streamvault.player.playback.PlaybackPreparationPlan
-import com.streamvault.player.playback.PlaybackRendererPlan
import com.streamvault.player.playback.PlaybackRetryContext
import com.streamvault.player.playback.PlayerDataSourceFactoryProvider
import com.streamvault.player.playback.PlayerErrorClassifier
@@ -59,6 +58,7 @@ import com.streamvault.player.playback.PlayerRetryPolicy
import com.streamvault.player.playback.PlayerTimeoutProfile
import com.streamvault.player.playback.PreloadCoordinator
import com.streamvault.player.playback.ResolvedStreamType
+import com.streamvault.player.playback.buildPlaybackRendererPlan
import com.streamvault.player.playback.resolveRetryAttemptAfterPlaybackStarted
import com.streamvault.player.playback.resolveRetryAttemptAfterReady
import com.streamvault.player.playback.resolveRetrySeekPositionMs
@@ -168,7 +168,6 @@ class Media3PlayerEngine @Inject constructor(
private var compatibilityMemoryEnabled: Boolean = true
private var audioOutputPath: String = "UNKNOWN"
private var compatibilityDecisionSource: String = "DEFAULT"
- private var pendingLearnedAudioFallback: PendingLearnedAudioFallback? = null
private var videoStallCount = 0
private var videoStallRecoveryAttempt = 0
private var videoStallSafeRecoveryPerformed = false
@@ -280,13 +279,6 @@ class Media3PlayerEngine @Inject constructor(
private var pendingTimeshiftAutoPlay: Boolean = false
private var lastAudioRendererRecoveryAtMs: Long = 0L
- private data class PendingLearnedAudioFallback(
- val mediaId: String,
- val streamType: String,
- val audioMimeTypes: List<String>,
- val detail: String?
- )
-
init {
startEngineCollectors()
}
@@ -833,7 +825,6 @@ class Media3PlayerEngine @Inject constructor(
hasRenderedFirstVideoFrame = false
prepareStartMs = System.currentTimeMillis()
audioCodecUnsupportedReported = false
- pendingLearnedAudioFallback = null
lastSupportErrorMessage = null
_error.tryEmit(null)
_mediaTitle.value = null
@@ -861,19 +852,12 @@ class Media3PlayerEngine @Inject constructor(
if (!preserveRetryState) {
recoveryDecoderPolicyOverride = null
}
- val learnedAudioCompatibility = if (requestedDecoderMode == DecoderMode.AUTO && compatibilityMemoryEnabled) {
- audioCompatibilityMemoryStore.lookup(mediaId, currentResolvedStreamType.name)
- } else {
- null
- }
val preferredDecoderMode = when {
requestedDecoderMode != DecoderMode.AUTO -> decoderPreferencePolicy.preferredMode(requestedDecoderMode, mediaId)
- learnedAudioCompatibility?.decision == AudioCompatibilityMemoryStore.DECISION_SOFTWARE_FFMPEG -> DecoderMode.SOFTWARE
else -> decoderPreferencePolicy.preferredMode(requestedDecoderMode, mediaId)
}
compatibilityDecisionSource = when {
requestedDecoderMode != DecoderMode.AUTO -> "USER_SELECTED"
- learnedAudioCompatibility != null -> "LEARNED_AUDIO_FALLBACK"
else -> "DEFAULT"
}
val nextDecoderPolicy = recoveryDecoderPolicyOverride ?: resolveActiveDecoderPolicy(
@@ -1038,6 +1022,7 @@ class Media3PlayerEngine @Inject constructor(
val requestedMode = requestedDecoderMode
val rendererPlan = buildPlaybackRendererPlan(
requestedMode = requestedMode,
+ activeDecoderMode = activeDecoderMode,
decoderPolicy = decoderPolicy,
useAudioVideoSyncSink = _audioVideoSyncEnabled.value,
useVideoRendererWorkaround = compatibilityProfile.shouldDisableDecoderReuseWorkaround()
@@ -1131,9 +1116,11 @@ class Media3PlayerEngine @Inject constructor(
)
}
setExtensionRendererMode(
- when (activeDecoderMode) {
- DecoderMode.AUTO, DecoderMode.HARDWARE -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON
- DecoderMode.SOFTWARE, DecoderMode.COMPATIBILITY -> DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER
+ when (rendererPlan.extensionRendererMode) {
+ PlaybackExtensionRendererMode.PLATFORM_FIRST ->
+ DefaultRenderersFactory.EXTENSION_RENDERER_MODE_ON
+ PlaybackExtensionRendererMode.EXTENSIONS_FIRST ->
+ DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER
}
)
}
@@ -1324,9 +1311,6 @@ class Media3PlayerEngine @Inject constructor(
}
if (hasAudioGroups && trackController.availableAudioTracks.value.isEmpty()) {
val mimeTypes = audioMimeTypes(tracks)
- if (tryFfmpegAudioFallback("audio-track-missing", mimeTypes, detail = null)) {
- return
- }
audioCodecUnsupportedReported = true
val mimeTypeLabel = mimeTypes.joinToString()
Log.w(
@@ -1415,17 +1399,6 @@ class Media3PlayerEngine @Inject constructor(
TAG,
"$reason streamType=$currentResolvedStreamType timeoutProfile=$currentTimeoutProfile audioPath=$audioOutputPath compatibilitySource=$compatibilityDecisionSource target=${PlaybackLogSanitizer.sanitizeUrl(lastStreamInfo?.url)}"
)
- pendingLearnedAudioFallback?.let { learned ->
- if (compatibilityMemoryEnabled && activeDecoderMode == DecoderMode.SOFTWARE) {
- audioCompatibilityMemoryStore.rememberSoftwareAudioFallback(
- mediaId = learned.mediaId,
- streamType = learned.streamType,
- audioMimeTypes = learned.audioMimeTypes,
- detail = learned.detail
- )
- }
- pendingLearnedAudioFallback = null
- }
recordCompatibilitySuccess()
refreshKnownBadCompatibilityRecords()
}
@@ -1704,17 +1677,6 @@ class Media3PlayerEngine @Inject constructor(
return
}
- if (
- source == "audio-codec" &&
- tryFfmpegAudioFallback(
- trigger = "audio-renderer-$source",
- mimeTypes = audioMimeTypes(),
- detail = error.message
- )
- ) {
- return
- }
-
val now = System.currentTimeMillis()
if (now - lastAudioRendererRecoveryAtMs < AUDIO_RENDERER_RECOVERY_COOLDOWN_MS) {
Log.e(
@@ -1751,75 +1713,6 @@ class Media3PlayerEngine @Inject constructor(
)
}
- private fun tryFfmpegAudioFallback(
- trigger: String,
- mimeTypes: List<String>,
- detail: String?
- ): Boolean {
- val streamInfo = lastStreamInfo ?: return false
- val mediaId = lastMediaId ?: return false
- val availability = ffmpegExtensionSupport.availability()
- ffmpegAvailability = availability
- if (!availability.available) {
- compatibilityDecisionSource = "FFMPEG_UNAVAILABLE"
- Log.w(
- TAG,
- "ffmpeg-audio-fallback unavailable trigger=$trigger target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)}"
- )
- return false
- }
- val supportedMimeTypes = ffmpegExtensionSupport.supportedAudioMimeTypes(mimeTypes)
- val effectiveSupportedMimeTypes = if (mimeTypes.isEmpty()) listOf("<unknown>") else supportedMimeTypes
- if (mimeTypes.isNotEmpty() && supportedMimeTypes.isEmpty()) {
- compatibilityDecisionSource = "FFMPEG_UNSUPPORTED_AUDIO"
- Log.w(
- TAG,
- "ffmpeg-audio-fallback unsupported trigger=$trigger mimeTypes=${mimeTypes.joinToString()} target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)}"
- )
- return false
- }
- val fallbackMode = decoderPreferencePolicy.onDecoderInitFailure(requestedDecoderMode, mediaId)
- if (
- !shouldAttemptFfmpegAudioFallback(
- FfmpegAudioFallbackRequest(
- requestedMode = requestedDecoderMode,
- extensionAvailable = availability.available,
- supportedMimeTypes = effectiveSupportedMimeTypes,
- fallbackMode = fallbackMode
- )
- )
- ) {
- return false
- }
- compatibilityDecisionSource = "FFMPEG_RETRY:$trigger"
- pendingLearnedAudioFallback = PendingLearnedAudioFallback(
- mediaId = mediaId,
- streamType = currentResolvedStreamType.name,
- audioMimeTypes = supportedMimeTypes,
- detail = detail
- )
- audioOutputPath = "FFMPEG_RETRY_PENDING"
-
- val wasPlaying = exoPlayer?.playWhenReady ?: true
- val seekPosition = exoPlayer?.currentPosition
- ?.takeIf { currentResolvedStreamType == ResolvedStreamType.PROGRESSIVE && it > 0L }
- Log.w(
- TAG,
- "ffmpeg-audio-fallback retry trigger=$trigger supportedMimeTypes=${effectiveSupportedMimeTypes.joinToString()} version=${availability.version ?: "unknown"} target=${PlaybackLogSanitizer.sanitizeUrl(streamInfo.url)} detail=${PlaybackLogSanitizer.sanitizeMessage(detail)}"
- )
-
- retryJob?.cancel()
- retryJob = null
- _retryStatus.value = null
- prepareInternal(
- streamInfo = streamInfo,
- preserveRetryState = false,
- seekPositionMs = seekPosition,
- autoPlay = wasPlaying
- )
- return true
- }
-
private fun audioMimeTypes(
tracks: androidx.media3.common.Tracks? = exoPlayer?.currentTracks
): List<String> {
@@ -1898,34 +1791,6 @@ class Media3PlayerEngine @Inject constructor(
)
}
- private fun buildPlaybackRendererPlan(
- requestedMode: DecoderMode,
- decoderPolicy: ActiveDecoderPolicy,
- useAudioVideoSyncSink: Boolean,
- useVideoRendererWorkaround: Boolean
- ): PlaybackRendererPlan {
- val useManagedCodecSelector = requestedMode != DecoderMode.AUTO && decoderPolicy != ActiveDecoderPolicy.AUTO
- val useEffectiveVideoRendererWorkaround = useVideoRendererWorkaround && requestedMode != DecoderMode.AUTO
- val renderPath = buildList {
- if (useAudioVideoSyncSink) add("av-sync-sink")
- if (useEffectiveVideoRendererWorkaround) add("decoder-reuse-workaround")
- if (useManagedCodecSelector) add("managed-codec-selector")
- }.ifEmpty { listOf("stock-media3") }.joinToString("+")
- return PlaybackRendererPlan(
- useAudioVideoSyncSink = useAudioVideoSyncSink,
- useVideoRendererWorkaround = useEffectiveVideoRendererWorkaround,
- useManagedCodecSelector = useManagedCodecSelector,
- renderPath = renderPath
- )
- }
-
- private fun shouldAttemptFfmpegAudioFallback(request: FfmpegAudioFallbackRequest): Boolean {
- if (request.requestedMode != DecoderMode.AUTO) return false
- if (!request.extensionAvailable) return false
- if (request.fallbackMode != DecoderMode.SOFTWARE) return false
- return request.supportedMimeTypes.isNotEmpty()
- }
-
private fun handlePlaybackSetupFailure(
error: Exception,
streamInfo: StreamInfo,
diff --git a/player/src/main/java/com/streamvault/player/PlayerEngine.kt b/player/src/main/java/com/streamvault/player/PlayerEngine.kt
index d2970629..6caff5e0 100644
--- a/player/src/main/java/com/streamvault/player/PlayerEngine.kt
+++ b/player/src/main/java/com/streamvault/player/PlayerEngine.kt
@@ -235,6 +235,8 @@ sealed class PlayerError(val message: String) {
PlaybackErrorCategory.NETWORK -> buildNetworkErrorMessage(chain)
PlaybackErrorCategory.HTTP_AUTH -> buildHttpErrorMessage(chain, "Access denied")
PlaybackErrorCategory.HTTP_SERVER -> buildHttpErrorMessage(chain, "Server error")
+ PlaybackErrorCategory.PROVIDER_LIMIT ->
+ "Provider rejected playback, likely max connections or bandwidth limit (HTTP 509)."
PlaybackErrorCategory.EMPTY_RESPONSE ->
"Provider returned an empty stream response (HTTP 204)."
PlaybackErrorCategory.SSL -> "Secure connection failed (SSL/TLS error)."
@@ -256,6 +258,7 @@ sealed class PlayerError(val message: String) {
PlaybackErrorCategory.CLEAR_TEXT_BLOCKED,
PlaybackErrorCategory.SSL -> NetworkError(msg)
+ PlaybackErrorCategory.PROVIDER_LIMIT,
PlaybackErrorCategory.EMPTY_RESPONSE,
PlaybackErrorCategory.SOURCE_MALFORMED,
PlaybackErrorCategory.LIVE_WINDOW -> SourceError(msg)
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 276f3db7..fc4bdd22 100644
--- a/player/src/main/java/com/streamvault/player/playback/CodecPreference.kt
+++ b/player/src/main/java/com/streamvault/player/playback/CodecPreference.kt
@@ -23,28 +23,49 @@ internal data class PlaybackRendererPlan(
val useAudioVideoSyncSink: Boolean,
val useVideoRendererWorkaround: Boolean,
val useManagedCodecSelector: Boolean,
+ val extensionRendererMode: PlaybackExtensionRendererMode,
val renderPath: String
) {
val useStockRenderersFactory: Boolean
get() = !useAudioVideoSyncSink && !useVideoRendererWorkaround
}
+internal enum class PlaybackExtensionRendererMode {
+ PLATFORM_FIRST,
+ EXTENSIONS_FIRST
+}
+
+internal fun extensionRendererModeFor(activeDecoderMode: DecoderMode): PlaybackExtensionRendererMode {
+ return when (activeDecoderMode) {
+ DecoderMode.AUTO,
+ DecoderMode.HARDWARE -> PlaybackExtensionRendererMode.PLATFORM_FIRST
+ DecoderMode.SOFTWARE,
+ DecoderMode.COMPATIBILITY -> PlaybackExtensionRendererMode.EXTENSIONS_FIRST
+ }
+}
+
internal fun buildPlaybackRendererPlan(
requestedMode: DecoderMode,
+ activeDecoderMode: DecoderMode,
decoderPolicy: ActiveDecoderPolicy,
useAudioVideoSyncSink: Boolean,
useVideoRendererWorkaround: Boolean
): PlaybackRendererPlan {
val useManagedCodecSelector = shouldUseManagedCodecSelector(requestedMode, decoderPolicy)
+ val extensionRendererMode = extensionRendererModeFor(activeDecoderMode)
val renderPath = buildList {
if (useAudioVideoSyncSink) add("av-sync-sink")
if (useVideoRendererWorkaround) add("decoder-reuse-workaround")
if (useManagedCodecSelector) add("managed-codec-selector")
+ if (extensionRendererMode == PlaybackExtensionRendererMode.PLATFORM_FIRST) {
+ add("platform-first-extension-audio-fallback")
+ }
}.ifEmpty { listOf("stock-media3") }.joinToString("+")
return PlaybackRendererPlan(
useAudioVideoSyncSink = useAudioVideoSyncSink,
useVideoRendererWorkaround = useVideoRendererWorkaround,
useManagedCodecSelector = useManagedCodecSelector,
+ extensionRendererMode = extensionRendererMode,
renderPath = renderPath
)
}
diff --git a/player/src/main/java/com/streamvault/player/playback/FfmpegExtensionSupport.kt b/player/src/main/java/com/streamvault/player/playback/FfmpegExtensionSupport.kt
index deebb5d6..6b1ae7e9 100644
--- a/player/src/main/java/com/streamvault/player/playback/FfmpegExtensionSupport.kt
+++ b/player/src/main/java/com/streamvault/player/playback/FfmpegExtensionSupport.kt
@@ -16,11 +16,11 @@ internal data class FfmpegAudioFallbackRequest(
val fallbackMode: DecoderMode?
)
+@Suppress("UNUSED_PARAMETER")
internal fun shouldAttemptFfmpegAudioFallback(request: FfmpegAudioFallbackRequest): Boolean {
- if (request.requestedMode != DecoderMode.AUTO) return false
- if (!request.extensionAvailable) return false
- if (request.fallbackMode != DecoderMode.SOFTWARE) return false
- return request.supportedMimeTypes.isNotEmpty()
+ // FFmpeg audio is exposed through Media3's platform-first extension renderer
+ // chain. Retrying into software mode would reopen the provider URL.
+ return false
}
@UnstableApi
diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerErrorClassifier.kt b/player/src/main/java/com/streamvault/player/playback/PlayerErrorClassifier.kt
index 07881a80..35011791 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlayerErrorClassifier.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerErrorClassifier.kt
@@ -16,6 +16,7 @@ enum class PlaybackErrorCategory {
NETWORK,
HTTP_AUTH,
HTTP_SERVER,
+ PROVIDER_LIMIT,
EMPTY_RESPONSE,
FORMAT_UNSUPPORTED,
DECODER,
@@ -45,6 +46,7 @@ object PlayerErrorClassifier {
playbackException?.errorCode == PlaybackException.ERROR_CODE_BEHIND_LIVE_WINDOW ->
PlaybackErrorCategory.LIVE_WINDOW
httpCode == 401 || httpCode == 403 || httpCode == 456 -> PlaybackErrorCategory.HTTP_AUTH
+ httpCode == 509 -> PlaybackErrorCategory.PROVIDER_LIMIT
httpCode == 204 -> PlaybackErrorCategory.EMPTY_RESPONSE
httpCode in setOf(408, 429, 500, 502, 503, 504) -> PlaybackErrorCategory.HTTP_SERVER
chain.any { it is SSLHandshakeException || it is SSLException } ||
@@ -77,7 +79,7 @@ object PlayerErrorClassifier {
}
private fun parseHttpStatus(message: String?): Int? {
- return Regex("""\b(204|401|403|408|429|456|500|502|503|504)\b""").find(message.orEmpty())
+ return Regex("""\b(204|401|403|408|429|456|500|502|503|504|509)\b""").find(message.orEmpty())
?.groupValues
?.getOrNull(1)
?.toIntOrNull()
diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt b/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
index d5de56e7..7f64015b 100644
--- a/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
+++ b/player/src/main/java/com/streamvault/player/playback/PlayerRetryPolicy.kt
@@ -62,6 +62,7 @@ class PlayerRetryPolicy(
PlaybackErrorCategory.LIVE_WINDOW -> "refresh-live-window"
PlaybackErrorCategory.NETWORK -> "transient-network"
PlaybackErrorCategory.HTTP_SERVER -> "server-retryable"
+ PlaybackErrorCategory.PROVIDER_LIMIT -> "provider-limit"
PlaybackErrorCategory.EMPTY_RESPONSE -> "empty-http-response"
else -> "retryable-source"
}
@@ -105,6 +106,7 @@ class PlayerRetryPolicy(
PlaybackErrorCategory.HTTP_AUTH,
PlaybackErrorCategory.FORMAT_UNSUPPORTED -> if (playbackStarted) 1 else 0
+ PlaybackErrorCategory.PROVIDER_LIMIT -> 0
PlaybackErrorCategory.LIVE_WINDOW -> 1
PlaybackErrorCategory.HTTP_SERVER -> {
val isProgressive = streamContext.resolvedStreamType == ResolvedStreamType.PROGRESSIVE
diff --git a/player/src/test/java/com/streamvault/player/PlayerErrorTest.kt b/player/src/test/java/com/streamvault/player/PlayerErrorTest.kt
new file mode 100644
index 00000000..8ae9c415
--- /dev/null
+++ b/player/src/test/java/com/streamvault/player/PlayerErrorTest.kt
@@ -0,0 +1,18 @@
+package com.streamvault.player
+
+import com.google.common.truth.Truth.assertThat
+import java.io.IOException
+import org.junit.Test
+
+class PlayerErrorTest {
+
+ @Test
+ fun `509 becomes source error instead of auth refresh network error`() {
+ val error = PlayerError.fromException(IOException("HTTP 509"))
+
+ assertThat(error).isInstanceOf(PlayerError.SourceError::class.java)
+ assertThat(error.message).isEqualTo(
+ "Provider rejected playback, likely max connections or bandwidth limit (HTTP 509)."
+ )
+ }
+}
diff --git a/player/src/test/java/com/streamvault/player/playback/FfmpegAudioFallbackPolicyTest.kt b/player/src/test/java/com/streamvault/player/playback/FfmpegAudioFallbackPolicyTest.kt
index a2dd7921..4e73e148 100644
--- a/player/src/test/java/com/streamvault/player/playback/FfmpegAudioFallbackPolicyTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/FfmpegAudioFallbackPolicyTest.kt
@@ -7,7 +7,7 @@ import org.junit.Test
class FfmpegAudioFallbackPolicyTest {
@Test
- fun `auto with supported mime and available extension retries once in software`() {
+ fun `auto with supported mime and available extension does not reprepare in software`() {
assertThat(
shouldAttemptFfmpegAudioFallback(
FfmpegAudioFallbackRequest(
@@ -17,7 +17,7 @@ class FfmpegAudioFallbackPolicyTest {
fallbackMode = DecoderMode.SOFTWARE
)
)
- ).isTrue()
+ ).isFalse()
}
@Test
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 8f14f23b..114cbf4f 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlaybackCodecSelectorTest.kt
@@ -47,66 +47,77 @@ class PlaybackCodecSelectorTest {
fun `auto default with av sync off uses stock media3 render path`() {
val plan = buildPlaybackRendererPlan(
requestedMode = DecoderMode.AUTO,
+ activeDecoderMode = DecoderMode.AUTO,
decoderPolicy = ActiveDecoderPolicy.AUTO,
useAudioVideoSyncSink = false,
useVideoRendererWorkaround = false
)
- assertThat(plan.renderPath).isEqualTo("stock-media3")
+ assertThat(plan.renderPath).isEqualTo("platform-first-extension-audio-fallback")
assertThat(plan.useStockRenderersFactory).isTrue()
assertThat(plan.useAudioVideoSyncSink).isFalse()
assertThat(plan.useManagedCodecSelector).isFalse()
+ assertThat(plan.extensionRendererMode).isEqualTo(PlaybackExtensionRendererMode.PLATFORM_FIRST)
}
@Test
fun `auto keeps decoder reuse workaround when compatibility requests it`() {
val plan = buildPlaybackRendererPlan(
requestedMode = DecoderMode.AUTO,
+ activeDecoderMode = DecoderMode.AUTO,
decoderPolicy = ActiveDecoderPolicy.AUTO,
useAudioVideoSyncSink = false,
useVideoRendererWorkaround = true
)
- assertThat(plan.renderPath).isEqualTo("decoder-reuse-workaround")
+ assertThat(plan.renderPath).isEqualTo("decoder-reuse-workaround+platform-first-extension-audio-fallback")
assertThat(plan.useStockRenderersFactory).isFalse()
assertThat(plan.useAudioVideoSyncSink).isFalse()
assertThat(plan.useVideoRendererWorkaround).isTrue()
assertThat(plan.useManagedCodecSelector).isFalse()
+ assertThat(plan.extensionRendererMode).isEqualTo(PlaybackExtensionRendererMode.PLATFORM_FIRST)
}
@Test
fun `auto with av sync on can combine audio video offset sink and decoder reuse workaround`() {
val plan = buildPlaybackRendererPlan(
requestedMode = DecoderMode.AUTO,
+ activeDecoderMode = DecoderMode.AUTO,
decoderPolicy = ActiveDecoderPolicy.AUTO,
useAudioVideoSyncSink = true,
useVideoRendererWorkaround = true
)
- assertThat(plan.renderPath).isEqualTo("av-sync-sink+decoder-reuse-workaround")
+ assertThat(plan.renderPath).isEqualTo(
+ "av-sync-sink+decoder-reuse-workaround+platform-first-extension-audio-fallback"
+ )
assertThat(plan.useStockRenderersFactory).isFalse()
assertThat(plan.useAudioVideoSyncSink).isTrue()
assertThat(plan.useVideoRendererWorkaround).isTrue()
assertThat(plan.useManagedCodecSelector).isFalse()
+ assertThat(plan.extensionRendererMode).isEqualTo(PlaybackExtensionRendererMode.PLATFORM_FIRST)
}
@Test
fun `explicit hardware uses managed codec selector`() {
val plan = buildPlaybackRendererPlan(
requestedMode = DecoderMode.HARDWARE,
+ activeDecoderMode = DecoderMode.HARDWARE,
decoderPolicy = ActiveDecoderPolicy.HARDWARE_PREFERRED,
useAudioVideoSyncSink = false,
useVideoRendererWorkaround = false
)
assertThat(plan.useManagedCodecSelector).isTrue()
- assertThat(plan.renderPath).isEqualTo("managed-codec-selector")
+ assertThat(plan.renderPath).isEqualTo("managed-codec-selector+platform-first-extension-audio-fallback")
+ assertThat(plan.extensionRendererMode).isEqualTo(PlaybackExtensionRendererMode.PLATFORM_FIRST)
}
@Test
fun `explicit software uses managed codec selector`() {
val plan = buildPlaybackRendererPlan(
requestedMode = DecoderMode.SOFTWARE,
+ activeDecoderMode = DecoderMode.SOFTWARE,
decoderPolicy = ActiveDecoderPolicy.SOFTWARE_PREFERRED,
useAudioVideoSyncSink = false,
useVideoRendererWorkaround = false
@@ -114,12 +125,29 @@ class PlaybackCodecSelectorTest {
assertThat(plan.useManagedCodecSelector).isTrue()
assertThat(plan.renderPath).isEqualTo("managed-codec-selector")
+ assertThat(plan.extensionRendererMode).isEqualTo(PlaybackExtensionRendererMode.EXTENSIONS_FIRST)
+ }
+
+ @Test
+ fun `mpeg l2 ffmpeg audio fallback keeps platform first video path`() {
+ val plan = buildPlaybackRendererPlan(
+ requestedMode = DecoderMode.AUTO,
+ activeDecoderMode = DecoderMode.AUTO,
+ decoderPolicy = ActiveDecoderPolicy.AUTO,
+ useAudioVideoSyncSink = false,
+ useVideoRendererWorkaround = false
+ )
+
+ assertThat(plan.useManagedCodecSelector).isFalse()
+ assertThat(plan.extensionRendererMode).isEqualTo(PlaybackExtensionRendererMode.PLATFORM_FIRST)
+ assertThat(plan.renderPath).contains("platform-first-extension-audio-fallback")
}
@Test
fun `explicit compatibility can combine managed selector and renderer workaround`() {
val plan = buildPlaybackRendererPlan(
requestedMode = DecoderMode.COMPATIBILITY,
+ activeDecoderMode = DecoderMode.COMPATIBILITY,
decoderPolicy = ActiveDecoderPolicy.COMPATIBILITY,
useAudioVideoSyncSink = false,
useVideoRendererWorkaround = true
diff --git a/player/src/test/java/com/streamvault/player/playback/PlayerErrorClassifierTest.kt b/player/src/test/java/com/streamvault/player/playback/PlayerErrorClassifierTest.kt
index 9ad3529b..18fdb1d9 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlayerErrorClassifierTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlayerErrorClassifierTest.kt
@@ -26,6 +26,12 @@ class PlayerErrorClassifierTest {
.isEqualTo(PlaybackErrorCategory.HTTP_AUTH)
}
+ @Test
+ fun `509 maps to provider limit`() {
+ assertThat(PlayerErrorClassifier.classify(IOException("HTTP 509")))
+ .isEqualTo(PlaybackErrorCategory.PROVIDER_LIMIT)
+ }
+
@Test
fun `204 maps to empty response`() {
assertThat(PlayerErrorClassifier.classify(IOException("HTTP 204")))
diff --git a/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt b/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
index 62b37ea4..f6a9e4d6 100644
--- a/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
+++ b/player/src/test/java/com/streamvault/player/playback/PlayerRetryPolicyTest.kt
@@ -39,6 +39,15 @@ class PlayerRetryPolicyTest {
.isFalse()
}
+ @Test
+ fun `509 never retries`() {
+ val error = IOException("HTTP 509")
+ assertThat(policy.shouldRetry(error, liveContext, playbackStarted = false, attempt = 1)).isFalse()
+ assertThat(policy.shouldRetry(error, liveContext, playbackStarted = true, attempt = 1)).isFalse()
+ assertThat(policy.maxAttempts(error, playbackStarted = false)).isEqualTo(0)
+ assertThat(policy.maxAttempts(error, playbackStarted = true)).isEqualTo(0)
+ }
+
@Test
fun `ssl error never retries`() {
assertThat(policy.shouldRetry(SSLHandshakeException("bad cert"), liveContext, playbackStarted = false, attempt = 1))