diff --git a/app/src/main/java/com/fongmi/android/tv/player/PlayerManager.java b/app/src/main/java/com/fongmi/android/tv/player/PlayerManager.java index 5a3d11ff80..34dd44a1d9 100644 --- a/app/src/main/java/com/fongmi/android/tv/player/PlayerManager.java +++ b/app/src/main/java/com/fongmi/android/tv/player/PlayerManager.java @@ -334,6 +334,8 @@ public class PlayerManager implements ParseCallback { private int mpvOutputEvaluationSeq; private int mpvAutoOutputProbeAttempts; private float userPlaybackSpeed = 1f; + /** Guards the one speed-change audio rebuild; {@link #rebuildAudioPipeline()} re-applies speed. */ + private boolean speedChangeAudioRebuildInProgress; private float networkProtectionSpeed = 1f; private float networkProtectionSupportedSpeed = 1f; private long networkProtectionMediaBitrate; @@ -1643,12 +1645,42 @@ public class PlayerManager implements ParseCallback { "apply request reason=%s requested=%.3f current=%.3f user=%.3f state=%d playing=%s loading=%s", reason, speed, current, userPlaybackSpeed, player.getPlaybackState(), player.isPlaying(), player.isLoading())); if (Math.abs(current - speed) < 0.001f) return; + prepareExoAudioForSpeed(speed, current, reason); player.setPlaybackParameters(player.getPlaybackParameters().withSpeed(speed)); logNetworkGuard(String.format(java.util.Locale.US, "apply result reason=%s requested=%.3f actual=%.3f", reason, speed, player.getPlaybackParameters().speed)); PlaybackTrace.log("exo-network-protection", playbackTrace.current(), "speed %.3f->%.3f reason=%s user=%.2f", current, speed, reason, userPlaybackSpeed); } + /** + * Tells the EXO engine the rate before the player applies it, and gives an already running + * compressed output the chance to become PCM once. A vendor compressed track is decoded by the + * device, so neither the sink's processors nor a later speed value can change its rate; only a + * pipeline that selects the format again at this rate can. Rebuilding on every change would + * reload the media for nothing, hence the one-shot guards: the rate has to leave 1x, the + * current output still has to be that compressed output, and a rebuild that re-applies the + * speed must not arrive here again. + */ + private void prepareExoAudioForSpeed(float speed, float current, String reason) { + if (!(engine instanceof ExoPlayerEngine exo)) return; + exo.setPlaybackSpeed(speed); + if (speedChangeAudioRebuildInProgress + || Math.abs(speed - 1f) < 0.001f + || Math.abs(current - 1f) >= 0.001f + || player.getPlaybackState() != Player.STATE_READY) return; + AudioPlaybackDiagnostics.OutputMode mode = getAudioPlaybackDiagnostics().outputMode(); + if (mode != AudioPlaybackDiagnostics.OutputMode.PASSTHROUGH + && mode != AudioPlaybackDiagnostics.OutputMode.COMPRESSED_DIRECT) return; + speedChangeAudioRebuildInProgress = true; + try { + PlaybackTrace.log("exo-audio-direct", playbackTrace.current(), + "speed %.3f->%.3f reason=%s rebuild=pcm", current, speed, reason); + rebuildAudioPipeline(); + } finally { + speedChangeAudioRebuildInProgress = false; + } + } + private void resetNetworkProtectionSession(String reason) { App.removeCallbacks(networkProtectionRunnable); networkProtectionController.reset(); diff --git a/app/src/main/java/com/fongmi/android/tv/player/engine/ExoPlayerEngine.java b/app/src/main/java/com/fongmi/android/tv/player/engine/ExoPlayerEngine.java index 70e32e3a96..1d3ec5a214 100644 --- a/app/src/main/java/com/fongmi/android/tv/player/engine/ExoPlayerEngine.java +++ b/app/src/main/java/com/fongmi/android/tv/player/engine/ExoPlayerEngine.java @@ -898,6 +898,15 @@ public class ExoPlayerEngine implements PlayerEngine { output.sampleRate(), output.tunneling(), reason); } + /** + * Forwards the rate the app is applying so the compressed-direct policy can refuse a vendor + * output that cannot implement it. Must happen before the player applies the parameters: the + * format/output claim is decided during configuration, not by the rate value seen later. + */ + public void setPlaybackSpeed(float speed) { + compressedAudioDirectPolicy.setPlaybackSpeed(speed); + } + private boolean isAudioDiagnosticsFailure(PlaybackException error, Format selectedAudio) { if (error == null) return false; if (isAudioOutputFailure(error)) return true; diff --git a/app/src/main/java/com/fongmi/android/tv/player/exo/ExoCompressedAudioDirectPolicy.java b/app/src/main/java/com/fongmi/android/tv/player/exo/ExoCompressedAudioDirectPolicy.java index a442794685..94d2f77e30 100644 --- a/app/src/main/java/com/fongmi/android/tv/player/exo/ExoCompressedAudioDirectPolicy.java +++ b/app/src/main/java/com/fongmi/android/tv/player/exo/ExoCompressedAudioDirectPolicy.java @@ -118,6 +118,13 @@ public final class ExoCompressedAudioDirectPolicy private final ExoAudioDirectFailureMemory failureMemory; private final OutputEnvironment environment; private volatile boolean audioPassthroughEnabled = true; + /** + * The rate the app asked playback to run at. Compressed direct frames are decoded by the + * device, outside Media3's PCM processors, so the rate has to be known while an encoded + * format is still being admitted; applying it afterwards cannot change a track that never + * leaves the HAL. + */ + private volatile float playbackSpeed = 1f; private final AtomicReference pendingPcmFallback = new AtomicReference<>(); private final AtomicBoolean initializationFailureNotified = new AtomicBoolean(); private final AtomicReference initializationFailureListener = @@ -176,6 +183,20 @@ public final class ExoCompressedAudioDirectPolicy } } + /** + * Sets the rate the next output selection must serve. A non-1.0 rate cannot run on the vendor + * compressed output: nothing in that path implements rate change (this build leaves Media3's + * output playback-parameters path disabled), so the decoder plus PCM path is the only one + * where the requested speed actually happens. + */ + public void setPlaybackSpeed(float speed) { + playbackSpeed = speed > 0f && !Float.isInfinite(speed) ? speed : 1f; + } + + private boolean speedRequiresPcm() { + return Math.abs(playbackSpeed - 1f) > 0.001f; + } + @Override public AudioOffloadSupport getAudioOffloadSupport( Format format, AudioAttributes audioAttributes) { @@ -252,6 +273,12 @@ public final class ExoCompressedAudioDirectPolicy return standard; } + if (speedRequiresPcm()) { + if (directKey != null) vendorDirectConfigs.remove(directKey); + logDecision(config.format, key, "vendor-direct-speed-requires-pcm"); + return standard; + } + // Do not let a failed vendor-direct configuration fall through to // the delegate's generic passthrough/direct claim. Media3 must see // it as unsupported on the next selection and choose decoder + PCM. @@ -285,8 +312,15 @@ public final class ExoCompressedAudioDirectPolicy } OutputKey key = OutputKey.from(config.format); AudioAttributes attributes = effectiveAttributes(config.audioAttributes); + DirectKey directKey = key == null ? null : new DirectKey(key, attributes); + if (speedRequiresPcm()) { + // A direct admission cached before the rate changed must not outlive it; the + // standard configuration below is the PCM one that can change rate. + if (directKey != null) vendorDirectConfigs.remove(directKey); + logDecision(config.format, key, "vendor-direct-speed-requires-pcm"); + } if (config.enableTunneling || key == null - || !vendorDirectConfigs.containsKey(new DirectKey(key, attributes))) { + || !vendorDirectConfigs.containsKey(directKey)) { try { return super.getOutputConfig(config); } catch (RuntimeException error) { diff --git a/app/src/test/java/com/fongmi/android/tv/player/exo/ExoCompressedAudioDirectPolicySpeedTest.java b/app/src/test/java/com/fongmi/android/tv/player/exo/ExoCompressedAudioDirectPolicySpeedTest.java new file mode 100644 index 0000000000..5e7b94da25 --- /dev/null +++ b/app/src/test/java/com/fongmi/android/tv/player/exo/ExoCompressedAudioDirectPolicySpeedTest.java @@ -0,0 +1,189 @@ +package com.fongmi.android.tv.player.exo; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThrows; + +import androidx.media3.common.AudioAttributes; +import androidx.media3.common.C; +import androidx.media3.common.Format; +import androidx.media3.common.MimeTypes; +import androidx.media3.common.util.Clock; +import androidx.media3.exoplayer.audio.AudioOffloadSupport; +import androidx.media3.exoplayer.audio.AudioOutput; +import androidx.media3.exoplayer.audio.AudioOutputProvider; + +import org.junit.Test; + +/** + * A vendor compressed output is decoded by the device and bypasses the PCM processors that + * implement rate change, so it may only be claimed at the native rate. + */ +public class ExoCompressedAudioDirectPolicySpeedTest { + + private static final float NATIVE = 1f; + + @Test + public void nativeSpeed_keepsVendorDirectClaim() { + ExoCompressedAudioDirectPolicy policy = policy(); + AudioOutputProvider wrapped = policy.wrapOutputProvider(unsupportedProvider()); + + assertEquals(AudioOutputProvider.FORMAT_SUPPORTED_DIRECTLY, + wrapped.getFormatSupport(formatConfig(format())).supportLevel); + + AudioOutputProvider.OutputConfig config = outputConfig(wrapped); + assertEquals(C.ENCODING_AAC_LC, config.encoding); + assertEquals(C.INDEX_UNSET, config.virtualDeviceId); + } + + @Test + public void fasterThanNative_refusesVendorDirectUpFront() { + ExoCompressedAudioDirectPolicy policy = policy(); + AudioOutputProvider wrapped = policy.wrapOutputProvider(unsupportedProvider()); + assertEquals(AudioOutputProvider.FORMAT_SUPPORTED_DIRECTLY, + wrapped.getFormatSupport(formatConfig(format())).supportLevel); + + policy.setPlaybackSpeed(3f); + + assertEquals(AudioOutputProvider.FormatSupport.UNSUPPORTED, + wrapped.getFormatSupport(formatConfig(format()))); + // The direct admission is withdrawn, so configuration falls back to the delegate's + // standard path instead of producing another offload/tunneling-free vendor config. + assertThrows(AudioOutputProvider.ConfigurationException.class, + () -> wrapped.getOutputConfig(formatConfig(format()))); + } + + @Test + public void slowerThanNative_refusesVendorDirectToo() { + ExoCompressedAudioDirectPolicy policy = policy(); + AudioOutputProvider wrapped = policy.wrapOutputProvider(unsupportedProvider()); + + policy.setPlaybackSpeed(0.5f); + + assertEquals(AudioOutputProvider.FormatSupport.UNSUPPORTED, + wrapped.getFormatSupport(formatConfig(format()))); + } + + @Test + public void directClaimIsDecidedByTheRateInForceAtSelectionTime() { + ExoCompressedAudioDirectPolicy policy = policy(); + AudioOutputProvider wrapped = policy.wrapOutputProvider(unsupportedProvider()); + + policy.setPlaybackSpeed(2.5f); + assertEquals(AudioOutputProvider.FormatSupport.UNSUPPORTED, + wrapped.getFormatSupport(formatConfig(format()))); + assertThrows(AudioOutputProvider.ConfigurationException.class, + () -> wrapped.getOutputConfig(formatConfig(format()))); + + // Back at the native rate the vendor output is admissible again: the gate withdraws a + // claim, it does not blacklist the configuration. + policy.setPlaybackSpeed(NATIVE); + assertEquals(AudioOutputProvider.FORMAT_SUPPORTED_DIRECTLY, + wrapped.getFormatSupport(formatConfig(format())).supportLevel); + assertNotNull(outputConfig(wrapped)); + } + + @Test + public void rateWithinToleranceOfNativeKeepsVendorDirectClaim() { + ExoCompressedAudioDirectPolicy policy = policy(); + AudioOutputProvider wrapped = policy.wrapOutputProvider(unsupportedProvider()); + + policy.setPlaybackSpeed(1.0005f); + + assertEquals(AudioOutputProvider.FORMAT_SUPPORTED_DIRECTLY, + wrapped.getFormatSupport(formatConfig(format())).supportLevel); + } + + @Test + public void invalidRateFallsBackToNativeSoTheClaimIsNotLost() { + ExoCompressedAudioDirectPolicy policy = policy(); + + policy.setPlaybackSpeed(Float.NaN); + + assertEquals(AudioOutputProvider.FORMAT_SUPPORTED_DIRECTLY, + policy.wrapOutputProvider(unsupportedProvider()) + .getFormatSupport(formatConfig(format())).supportLevel); + } + + private static AudioOutputProvider.OutputConfig outputConfig(AudioOutputProvider wrapped) { + try { + AudioOutputProvider.OutputConfig config = + wrapped.getOutputConfig(formatConfig(format())); + assertNotNull(config); + return config; + } catch (AudioOutputProvider.ConfigurationException error) { + throw new AssertionError("expected a vendor direct config", error); + } + } + + private static ExoCompressedAudioDirectPolicy policy() { + return new ExoCompressedAudioDirectPolicy( + (format, attributes) -> AudioOffloadSupport.DEFAULT_UNSUPPORTED, + (format, attributes) -> true, + Clock.DEFAULT, + config -> { + throw new AudioOutputProvider.InitializationException(); + }, + new ExoAudioDirectFailureMemory(), + new ExoCompressedAudioDirectPolicy.OutputEnvironment() { + @Override + public ExoAudioDirectFailureMemory.Route expectedRoute( + AudioAttributes attributes) { + return null; + } + + @Override + public ExoAudioDirectFailureMemory.Route actualRoute(AudioOutput output) { + return null; + } + }); + } + + private static AudioOutputProvider unsupportedProvider() { + return new AudioOutputProvider() { + @Override + public FormatSupport getFormatSupport(FormatConfig config) { + return FormatSupport.UNSUPPORTED; + } + + @Override + public OutputConfig getOutputConfig(FormatConfig config) + throws ConfigurationException { + throw new ConfigurationException("standard path"); + } + + @Override + public AudioOutput getAudioOutput(OutputConfig config) + throws InitializationException { + throw new InitializationException(); + } + + @Override + public void addListener(Listener listener) { + } + + @Override + public void removeListener(Listener listener) { + } + + @Override + public void release() { + } + }; + } + + private static AudioOutputProvider.FormatConfig formatConfig(Format format) { + return new AudioOutputProvider.FormatConfig.Builder(format) + .setAudioAttributes(AudioAttributes.DEFAULT) + .build(); + } + + private static Format format() { + return new Format.Builder() + .setSampleMimeType(MimeTypes.AUDIO_AAC) + .setCodecs("mp4a.40.2") + .setSampleRate(48_000) + .setChannelCount(2) + .build(); + } +} diff --git a/docs/SPEED-01-exo-direct-playback-speed.md b/docs/SPEED-01-exo-direct-playback-speed.md new file mode 100644 index 0000000000..e6d9f35af5 --- /dev/null +++ b/docs/SPEED-01-exo-direct-playback-speed.md @@ -0,0 +1,79 @@ +# SPEED-01 · EXO 压缩直通导致倍速完全失效 + +## 1. 现象 + +真机诊断包(用户导出,只读): + +`/run/user/1000/gvfs/smb-share:server=192.168.50.3,share=users/Maple/共享/webhtv-debug-log (3) (6).txt` + +- `play.clock`:player 上报 `speed=5.0/3.0/2.5`,但 `positionMs` 每 5000 ms 墙钟只推进约 5000 ms(1.00×)。 + 倍速完全没生效,0.5× 同样失效。 +- `audio.output.configure`:`encoding=10`(AAC-LC,压缩而非 PCM)、`offload=false`、`tunneling=false`。 +- `audio.candidates`:`support=2`,即 `AudioOutputProvider.FORMAT_SUPPORTED_DIRECTLY`,判定由 + `ExoCompressedAudioDirectPolicy` 的厂商压缩直通路径给出。 +- 时序:`audio.processing stage=requested-parameters speed=5.0` 在 11:34:57.398, + `audio.output.configure` 在 11:34:57.499 —— 输出配置时 sink 的 speed 已经是 5.0, + 所以在选择/配置阶段加门禁即可覆盖用户报告的场景。 + +## 2. 根因链 + +1. media3 的倍速只有两条实现路径:PCM 域的 `SonicAudioProcessor`,或 + `AudioOutput.setPlaybackParameters`(`AudioTrack.setPlaybackParams`)。 +2. 后者由 `DefaultAudioSink.useAudioOutputPlaybackParams()` 决定,读 + `OutputConfig.usePlaybackParameters`;`ExoCompressedAudioDirectPolicy.java:323-324` 写的是 + `setUsePlaybackParameters(config.enablePlaybackParameters)`,该值来自 + `DefaultRenderersFactory.enableAudioOutputPlaybackParameters`,media3 默认 false, + 本仓库除 `ExoUtil.java:1060` 的转发外没有任何地方打开它。 +3. 压缩直通输出不经过处理器链,于是 Sonic 分支对该输出等于什么都不做 → 速率恒为 1×。 +4. media3 自带的兜底 `DefaultAudioSink.maybeDisableOffload()` 开头即 `if (!config.isOffload) return;`, + 而 `ExoCompressedAudioDirectPolicy.java:319` 显式 `setIsOffload(false)`, + 所以"要变速就退回 PCM"的保护永远不会触发。 +5. 直通准入发生在**格式/输出选择与配置**阶段(`getFormatSupport` → `getOutputConfig` → + `getAudioOutput`),此时策略对象并不知道播放速率,所以它照样给出直通配置。 + +结论:只要在非 1.0× 时不让这套策略认领压缩直通格式,media3 就会走解码器 + PCM, +倍速由 Sonic 真正实现;1.0× 仍走直通,保留 E11 的收益。 + +## 3. 改动点 + +| 文件 | 改动 | +| --- | --- | +| `app/.../exo/ExoCompressedAudioDirectPolicy.java` | 新增 `volatile float playbackSpeed = 1f`、`public void setPlaybackSpeed(float)`、`speedRequiresPcm()`;`getFormatSupport` 与 `getOutputConfig` 在既有 `audioPassthroughEnabled` 检查之后、直通准入判断之内加门禁:`Math.abs(speed-1f) > 0.001f` 时 `vendorDirectConfigs.remove(directKey)` 并 `logDecision(..., "vendor-direct-speed-requires-pcm")`,前者返回 `standard`,后者回落 `super.getOutputConfig(config)`。 | +| `app/.../engine/ExoPlayerEngine.java` | 新增 `public void setPlaybackSpeed(float)`,转发到已持有的 `compressedAudioDirectPolicy`。 | +| `app/.../PlayerManager.java` | `applyEffectiveSpeed` 在 `player.setPlaybackParameters(...)` **之前**调用新增的 `prepareExoAudioForSpeed`:先 `exo.setPlaybackSpeed(speed)`,再在 `isExo()` + 速率离开 1× + 上一步仍是 1× + 播放已 READY + `getAudioPlaybackDiagnostics().outputMode()` 仍是压缩输出(`PASSTHROUGH`/`COMPRESSED_DIRECT`)时,用 `speedChangeAudioRebuildInProgress` 一次性标志调用一次 `rebuildAudioPipeline()`,防止 `rebuildAudioPipeline` 内部 `setSpeed` 再触发重建。 | + +不改动:`setEnableAudioOutputPlaybackParameters` 的取值(全仓仍为 false)、AC3/EAC3/DTS 的 offload 语义、 +E11 的成功路径判定。 + +## 4. 验证 + +- `bash ./gradlew :app:testMobileArm64_v8aDebugUnitTest --tests "*ExoCompressedAudioDirectPolicySpeedTest" --console=plain` + → `BUILD SUCCESSFUL in 1m 53s`;新增 6 例全部通过(`tests="6" failures="0" errors="0"`), + 覆盖:1.0× 仍返回 `FORMAT_SUPPORTED_DIRECTLY` 且仍是厂商直通配置;3.0× / 2.5× / 0.5× 返回不含直通的 + standard 结果并回落到 `super.getOutputConfig`;回到 1.0× 后重新可认领直通;1.0005× 在容差内不触发门禁; + NaN 回落为 1.0×。 +- 编译由同一条测试任务覆盖(`:app:compileMobileArm64_v8aDebugJavaWithJavac` / `...UnitTestJavaWithJavac` 均为该任务的依赖)。 + +## 5. 残余风险 + +- 1×→非 1× 的首次切换会触发一次 `rebuildAudioPipeline()`:表现为一次短暂重载(重新 prepare 并回到原位置)。 + 非 1×→非 1× 的后续改速不再重建;1× 从不重建。 +- 该重建依赖播放处于 `STATE_READY` 且诊断输出的 `OutputMode` 已经可见(`getAudioPlaybackDiagnostics()` + 需要当前播放会话的 trace 一致)。若此刻诊断仍为 `UNKNOWN`,本次不会重建,仅靠选择期门禁在下次 + 输出配置生效。 +- 回落 PCM 后,高码率多声道音轨(如 5.1 真 Dolby/DTS 的压缩帧)需要设备以 PCM 承载同样通道数; + 设备 PCM 通道/采样率能力不足时会出现下混或失败,此时由既有 PCM 失败/回退链路接管, + 不再享受 E11 直通收益。 +- 回到 1.0× 时只重新打开直通准入,不会主动重建回直通输出;E11 收益在下一次输出配置/管线重建时恢复。 + +## 6. 回滚 + +`git revert <本任务提交 SHA>`(等价于还原上面三处改动 + 删除对应单测与本文档)。 +恢复后行为立即回到"压缩直通 + 倍速无效",与改动前一致。 + +## Recovery anchor + +- 目标:非 1.0× 时 EXO 退出厂商压缩直通改走 PCM+Sonic,使倍速真实生效;1.0× 保留 E11 直通。 +- 状态:实现 + 定向单测通过(待提交)。 +- 回滚锚点:本任务提交(`fix(exo): 倍速非 1.0 时退出压缩直通并回落 PCM`)及其 `recovery/SPEED-01/` 标签。 +- 下一步:真机复测 5.0×/3.0×/0.5× 的 `play.clock` 是否与墙钟同比,并确认 1.0× 仍报 `support=2` 直通。