Use the AV1 sample dependency parser in MCVR

Parsing AV1 bitstreams allows us to identify frames that are
not used as reference, and improve seeking or frame dropping
behavior.

The AV1 bitstream format is relatively quick to parse

PiperOrigin-RevId: 723462680

Author: ychaparov

RELEASENOTES.md

@@ -19,6 +19,9 @@
         protected so that applications can override to block usage of
         placeholder surfaces
         ([#1905](https://github.com/androidx/media/pull/1905)).
+    *   Add experimental `ExoPlayer` AV1 sample dependency parsing to speed up
+        seeking. Enable it with the new
+        `DefaultRenderersFactory.experimentalSetParseAv1SampleDependencies` API.
 *   Text:
 *   Metadata:
 *   Image:

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/DefaultRenderersFactory.java

@@ -25,6 +25,7 @@
 import androidx.annotation.IntDef;
 import androidx.annotation.Nullable;
 import androidx.media3.common.C;
+import androidx.media3.common.MimeTypes;
 import androidx.media3.common.util.Log;
 import androidx.media3.common.util.UnstableApi;
 import androidx.media3.exoplayer.audio.AudioRendererEventListener;
@@ -108,6 +109,7 @@ public class DefaultRenderersFactory implements RenderersFactory {
   private boolean enableFloatOutput;
   private boolean enableAudioTrackPlaybackParams;
   private boolean enableMediaCodecVideoRendererPrewarming;
+  private boolean parseAv1SampleDependencies;
 
   /**
    * @param context A {@link Context}.
@@ -276,6 +278,24 @@ public final DefaultRenderersFactory experimentalSetEnableMediaCodecVideoRendere
     return this;
   }
 
+  /**
+   * Sets whether {@link MimeTypes#VIDEO_AV1} bitstream parsing for sample dependency information is
+   * enabled. Knowing which input frames are not depended on can speed up seeking and reduce dropped
+   * frames.
+   *
+   * Defaults to {@code false}.
+   *
+   * This method is experimental and will be renamed or removed in a future release.
+   *
+   * @param parseAv1SampleDependencies Whether bitstream parsing is enabled.
+   */
+  @CanIgnoreReturnValue
+  public final DefaultRenderersFactory experimentalSetParseAv1SampleDependencies(
+      boolean parseAv1SampleDependencies) {
+    this.parseAv1SampleDependencies = parseAv1SampleDependencies;
+    return this;
+  }
+
   /**
    * Sets the maximum duration for which video renderers can attempt to seamlessly join an ongoing
    * playback.
@@ -375,6 +395,7 @@ protected void buildVideoRenderers(
             .setEventHandler(eventHandler)
             .setEventListener(eventListener)
             .setMaxDroppedFramesToNotify(MAX_DROPPED_VIDEO_FRAME_COUNT_TO_NOTIFY)
+            .experimentalSetParseAv1SampleDependencies(parseAv1SampleDependencies)
             .build();
     out.add(videoRenderer);
 
@@ -778,6 +799,7 @@ protected Renderer buildSecondaryVideoRenderer(
           .setEventHandler(eventHandler)
           .setEventListener(eventListener)
           .setMaxDroppedFramesToNotify(MAX_DROPPED_VIDEO_FRAME_COUNT_TO_NOTIFY)
+          .experimentalSetParseAv1SampleDependencies(parseAv1SampleDependencies)
           .build();
     }
     return null;

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/MediaCodecVideoRenderer.java

@@ -157,6 +157,7 @@ public class MediaCodecVideoRenderer extends MediaCodecRenderer
   private final boolean deviceNeedsNoPostProcessWorkaround;
   private final VideoFrameReleaseControl videoFrameReleaseControl;
   private final VideoFrameReleaseControl.FrameReleaseInfo videoFrameReleaseInfo;
+  @Nullable private final Av1SampleDependencyParser av1SampleDependencyParser;
 
   private @MonotonicNonNull CodecMaxValues codecMaxValues;
   private boolean codecNeedsSetOutputSurfaceWorkaround;
@@ -202,6 +203,7 @@ public static final class Builder {
     private int maxDroppedFramesToNotify;
     private float assumedMinimumCodecOperatingRate;
     @Nullable private VideoSink videoSink;
+    private boolean parseAv1SampleDependencies;
 
     /**
      * Creates a new builder.
@@ -310,6 +312,21 @@ public Builder setVideoSink(@Nullable VideoSink videoSink) {
       return this;
     }
 
+    /**
+     * Sets whether {@link MimeTypes#VIDEO_AV1} bitstream parsing for sample dependency information
+     * is enabled. Knowing which input frames are not depended on can speed up seeking and reduce
+     * dropped frames.
+     *
+     * Defaults to {@code false}.
+     *
+     * This method is experimental and will be renamed or removed in a future release.
+     */
+    @CanIgnoreReturnValue
+    public Builder experimentalSetParseAv1SampleDependencies(boolean parseAv1SampleDependencies) {
+      this.parseAv1SampleDependencies = parseAv1SampleDependencies;
+      return this;
+    }
+
     /**
      * Builds the {@link MediaCodecVideoRenderer}. Must only be called once per Builder instance.
      *
@@ -527,6 +544,8 @@ protected MediaCodecVideoRenderer(Builder builder) {
     rendererPriority = C.PRIORITY_PLAYBACK;
     startPositionUs = C.TIME_UNSET;
     periodDurationUs = C.TIME_UNSET;
+    av1SampleDependencyParser =
+        builder.parseAv1SampleDependencies ? new Av1SampleDependencyParser() : null;
   }
 
   // FrameTimingEvaluator methods
@@ -1397,10 +1416,6 @@ protected int getCodecBufferFlags(DecoderInputBuffer buffer) {
 
   @Override
   protected boolean shouldSkipDecoderInputBuffer(DecoderInputBuffer buffer) {
-    if (!buffer.notDependedOn()) {
-      // Buffer is depended on. Do not skip.
-      return false;
-    }
     if (isBufferProbablyLastSample(buffer)) {
       // Make sure to decode and render the last frame.
       return false;
@@ -1411,7 +1426,23 @@ protected boolean shouldSkipDecoderInputBuffer(DecoderInputBuffer buffer) {
       return false;
     }
     // Skip buffers without sample dependencies that won't be rendered.
-    return isBufferBeforeStartTime(buffer);
+    if (!isBufferBeforeStartTime(buffer)) {
+      return false;
+    }
+    if (buffer.notDependedOn()) {
+      return true;
+    }
+    if (av1SampleDependencyParser != null
+        && checkNotNull(getCodecInfo()).mimeType.equals(MimeTypes.VIDEO_AV1)
+        && buffer.data != null) {
+      ByteBuffer readOnlySample = buffer.data.asReadOnlyBuffer();
+      readOnlySample.flip();
+      int sampleLimitAfterSkippingNonReferenceFrames =
+          av1SampleDependencyParser.sampleLimitAfterSkippingNonReferenceFrame(readOnlySample);
+      // TODO: b/391108133 - support skipping parts of AV1 input buffers.
+      return sampleLimitAfterSkippingNonReferenceFrames == readOnlySample.position();
+    }
+    return false;
   }
 
   private boolean isBufferProbablyLastSample(DecoderInputBuffer buffer) {

libraries/exoplayer/src/test/java/androidx/media3/exoplayer/e2etest/ParseAv1SampleDependenciesPlaybackTest.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.media3.exoplayer.e2etest;
+
+import android.content.Context;
+import android.graphics.SurfaceTexture;
+import android.view.Surface;
+import androidx.media3.common.MediaItem;
+import androidx.media3.common.MediaItem.ClippingConfiguration;
+import androidx.media3.common.Player;
+import androidx.media3.exoplayer.ExoPlayer;
+import androidx.media3.test.utils.CapturingRenderersFactory;
+import androidx.media3.test.utils.DumpFileAsserts;
+import androidx.media3.test.utils.FakeClock;
+import androidx.media3.test.utils.robolectric.PlaybackOutput;
+import androidx.media3.test.utils.robolectric.ShadowMediaCodecConfig;
+import androidx.media3.test.utils.robolectric.TestPlayerRunHelper;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** End-to-end playback tests using AV1 sample skipping. */
+@RunWith(AndroidJUnit4.class)
+public class ParseAv1SampleDependenciesPlaybackTest {
+
+  private static final String TEST_MP4_URI = "asset:///media/mp4/sample_with_av1c.mp4";
+
+  @Rule
+  public ShadowMediaCodecConfig mediaCodecConfig =
+      ShadowMediaCodecConfig.forAllSupportedMimeTypes();
+
+  @Test
+  public void playback_withClippedMediaItem_skipNonReferenceInputSamples() throws Exception {
+    Context applicationContext = ApplicationProvider.getApplicationContext();
+    CapturingRenderersFactory renderersFactory = new CapturingRenderersFactory(applicationContext);
+    renderersFactory.experimentalSetParseAv1SampleDependencies(true);
+    ExoPlayer player =
+        new ExoPlayer.Builder(applicationContext, renderersFactory)
+            .setClock(new FakeClock(/* isAutoAdvancing= */ true))
+            .build();
+    Surface surface = new Surface(new SurfaceTexture(/* texName= */ 1));
+    player.setVideoSurface(surface);
+    PlaybackOutput playbackOutput = PlaybackOutput.register(player, renderersFactory);
+    player.setMediaItem(
+        new MediaItem.Builder()
+            .setUri(TEST_MP4_URI)
+            .setClippingConfiguration(
+                new ClippingConfiguration.Builder().setStartPositionMs(200).build())
+            .build());
+
+    player.prepare();
+    player.play();
+    TestPlayerRunHelper.runUntilPlaybackState(player, Player.STATE_ENDED);
+    player.release();
+    surface.release();
+
+    DumpFileAsserts.assertOutput(
+        applicationContext,
+        playbackOutput,
+        /* dumpFile= */ "playbackdumps/av1SampleDependencies/clippedMediaItem.dump");
+  }
+}