Wire up experiment to use AdaptiveTrackSelection based selections

LegacyVideoTrackSelection is the previous implementation (unchanged).
VideoTrackSelection is rewritten to extend AdaptiveTrackSelection.

An experiment is added to allow use of the new VideoTrackSelection
implementation. It's envisaged that this transition will be more or
less a no-op change. The experiment flag is only in case of bugs
during roll-out, and will be removed with LegacyVideoTrackSelection
upon successful transition.

VideoTrackSelection also implements discard-on-trick-play-exit, which
was a TODO in the previous implementation.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=221153827

library/core/src/main/java/com/google/android/exoplayer2/trackselection/AdaptiveTrackSelection.java

@@ -255,7 +255,7 @@ public class AdaptiveTrackSelection extends BaseTrackSelection {
   private final Clock clock;
   private final Clock clock;
   private final Format[] formats;
   private final Format[] formats;
   private final int[] formatBitrates;
   private final int[] formatBitrates;
-  private final int[] estimatedBitrates;
+  private final int[] trackBitrates;
 
 
   private TrackBitrateEstimator trackBitrateEstimator;
   private TrackBitrateEstimator trackBitrateEstimator;
   private float playbackSpeed;
   private float playbackSpeed;
@@ -338,7 +338,7 @@ public class AdaptiveTrackSelection extends BaseTrackSelection {
     trackBitrateEstimator = TrackBitrateEstimator.DEFAULT;
     trackBitrateEstimator = TrackBitrateEstimator.DEFAULT;
     formats = new Format[length];
     formats = new Format[length];
     formatBitrates = new int[length];
     formatBitrates = new int[length];
-    estimatedBitrates = new int[length];
+    trackBitrates = new int[length];
     for (int i = 0; i < length; i++) {
     for (int i = 0; i < length; i++) {
       @SuppressWarnings("nullness:method.invocation.invalid")
       @SuppressWarnings("nullness:method.invocation.invalid")
       Format format = getFormat(i);
       Format format = getFormat(i);
@@ -380,11 +380,12 @@ public class AdaptiveTrackSelection extends BaseTrackSelection {
       MediaChunkIterator[] mediaChunkIterators) {
       MediaChunkIterator[] mediaChunkIterators) {
     long nowMs = clock.elapsedRealtime();
     long nowMs = clock.elapsedRealtime();
 
 
-    trackBitrateEstimator.getBitrates(formats, queue, mediaChunkIterators, estimatedBitrates);
+    // Update the estimated track bitrates.
+    trackBitrateEstimator.getBitrates(formats, queue, mediaChunkIterators, trackBitrates);
 
 
     // Stash the current selection, then make a new one.
     // Stash the current selection, then make a new one.
     int currentSelectedIndex = selectedIndex;
     int currentSelectedIndex = selectedIndex;
-    selectedIndex = determineIdealSelectedIndex(nowMs, estimatedBitrates);
+    selectedIndex = determineIdealSelectedIndex(nowMs, trackBitrates);
     if (selectedIndex == currentSelectedIndex) {
     if (selectedIndex == currentSelectedIndex) {
       return;
       return;
     }
     }
@@ -429,10 +430,10 @@ public class AdaptiveTrackSelection extends BaseTrackSelection {
   @Override
   @Override
   public int evaluateQueueSize(long playbackPositionUs, List<? extends MediaChunk> queue) {
   public int evaluateQueueSize(long playbackPositionUs, List<? extends MediaChunk> queue) {
     long nowMs = clock.elapsedRealtime();
     long nowMs = clock.elapsedRealtime();
-    if (lastBufferEvaluationMs != C.TIME_UNSET
-        && nowMs - lastBufferEvaluationMs < minTimeBetweenBufferReevaluationMs) {
+    if (!shouldEvaluateQueueSize(nowMs)) {
       return queue.size();
       return queue.size();
     }
     }
+
     lastBufferEvaluationMs = nowMs;
     lastBufferEvaluationMs = nowMs;
     if (queue.isEmpty()) {
     if (queue.isEmpty()) {
       return 0;
       return 0;
@@ -443,6 +444,7 @@ public class AdaptiveTrackSelection extends BaseTrackSelection {
     long playoutBufferedDurationBeforeLastChunkUs =
     long playoutBufferedDurationBeforeLastChunkUs =
         Util.getPlayoutDurationForMediaDuration(
         Util.getPlayoutDurationForMediaDuration(
             lastChunk.startTimeUs - playbackPositionUs, playbackSpeed);
             lastChunk.startTimeUs - playbackPositionUs, playbackSpeed);
+    long minDurationToRetainAfterDiscardUs = getMinDurationToRetainAfterDiscardUs();
     if (playoutBufferedDurationBeforeLastChunkUs < minDurationToRetainAfterDiscardUs) {
     if (playoutBufferedDurationBeforeLastChunkUs < minDurationToRetainAfterDiscardUs) {
       return queueSize;
       return queueSize;
     }
     }
@@ -469,18 +471,58 @@ public class AdaptiveTrackSelection extends BaseTrackSelection {
   }
   }
 
 
   /**
   /**
+   * Called when updating the selected track to determine whether a candidate track can be selected.
+   *
+   * @param format The {@link Format} of the candidate track.
+   * @param trackBitrate The estimated bitrate of the track. May differ from {@link Format#bitrate}
+   *     if a more accurate estimate of the current track bitrate is available.
+   * @param playbackSpeed The current playback speed.
+   * @param effectiveBitrate The bitrate available to this selection.
+   * @return Whether this {@link Format} can be selected.
+   */
+  @SuppressWarnings("unused")
+  protected boolean canSelectFormat(
+      Format format, int trackBitrate, float playbackSpeed, long effectiveBitrate) {
+    return Math.round(trackBitrate * playbackSpeed) <= effectiveBitrate;
+  }
+
+  /**
+   * Called from {@link #evaluateQueueSize(long, List)} to determine whether an evaluation should be
+   * performed.
+   *
+   * @param nowMs The current value of {@link Clock#elapsedRealtime()}.
+   * @return Whether an evaluation should be performed.
+   */
+  protected boolean shouldEvaluateQueueSize(long nowMs) {
+    return lastBufferEvaluationMs == C.TIME_UNSET
+        || nowMs - lastBufferEvaluationMs >= minTimeBetweenBufferReevaluationMs;
+  }
+
+  /**
+   * Called from {@link #evaluateQueueSize(long, List)} to determine the minimum duration of buffer
+   * to retain after discarding chunks.
+   *
+   * @return The minimum duration of buffer to retain after discarding chunks, in microseconds.
+   */
+  protected long getMinDurationToRetainAfterDiscardUs() {
+    return minDurationToRetainAfterDiscardUs;
+  }
+
+  /**
    * Computes the ideal selected index ignoring buffer health.
    * Computes the ideal selected index ignoring buffer health.
    *
    *
    * @param nowMs The current time in the timebase of {@link Clock#elapsedRealtime()}, or {@link
    * @param nowMs The current time in the timebase of {@link Clock#elapsedRealtime()}, or {@link
    *     Long#MIN_VALUE} to ignore blacklisting.
    *     Long#MIN_VALUE} to ignore blacklisting.
-   * @param bitrates Track bitrates.
+   * @param trackBitrates The estimated track bitrates. May differ from format bitrates if more
+   *     accurate estimates of the current track bitrates are available.
    */
    */
-  private int determineIdealSelectedIndex(long nowMs, int[] bitrates) {
+  private int determineIdealSelectedIndex(long nowMs, int[] trackBitrates) {
     long effectiveBitrate = (long) (bandwidthMeter.getBitrateEstimate() * bandwidthFraction);
     long effectiveBitrate = (long) (bandwidthMeter.getBitrateEstimate() * bandwidthFraction);
     int lowestBitrateNonBlacklistedIndex = 0;
     int lowestBitrateNonBlacklistedIndex = 0;
     for (int i = 0; i < length; i++) {
     for (int i = 0; i < length; i++) {
       if (nowMs == Long.MIN_VALUE || !isBlacklisted(i, nowMs)) {
       if (nowMs == Long.MIN_VALUE || !isBlacklisted(i, nowMs)) {
-        if (Math.round(bitrates[i] * playbackSpeed) <= effectiveBitrate) {
+        Format format = getFormat(i);
+        if (canSelectFormat(format, trackBitrates[i], playbackSpeed, effectiveBitrate)) {
           return i;
           return i;
         } else {
         } else {
           lowestBitrateNonBlacklistedIndex = i;
           lowestBitrateNonBlacklistedIndex = i;