Apply comparator-driven ABR selection without default-specific branching

Author: AndyWangLYN

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/AdaptiveTrackSelection.java

@@ -528,7 +528,7 @@ public void updateSelectedTrack(
     // Make initial selection
     if (reason == C.SELECTION_REASON_UNKNOWN) {
       reason = C.SELECTION_REASON_INITIAL;
-      selectedIndex = determineIdealSelectedIndexForEffectiveBitrate(nowMs, effectiveBitrate);
+      selectedIndex = determineIdealSelectedIndex(nowMs, effectiveBitrate);
       return;
     }
 
@@ -540,11 +540,10 @@ public void updateSelectedTrack(
       previousSelectedIndex = formatIndexOfPreviousChunk;
       previousReason = Iterables.getLast(queue).trackSelectionReason;
     }
-    int newSelectedIndex = determineIdealSelectedIndexForEffectiveBitrate(nowMs, effectiveBitrate);
+    int newSelectedIndex = determineIdealSelectedIndex(nowMs, effectiveBitrate);
     if (newSelectedIndex != previousSelectedIndex
         && !isTrackExcluded(previousSelectedIndex, nowMs)) {
-      // Revert back to the previous selection if conditions are not suitable for switching. Do not
-      // defer a switch when the previous format no longer fits into available bandwidth.
+      // Revert back to the previous selection if conditions are not suitable for switching.
       long minDurationForQualityIncreaseUs =
           minDurationForQualityIncreaseUs(availableDurationUs, chunkDurationUs);
       if (newSelectedIndex < previousSelectedIndex
@@ -553,11 +552,9 @@ public void updateSelectedTrack(
         // up. Defer switching up for now.
         newSelectedIndex = previousSelectedIndex;
       } else if (newSelectedIndex > previousSelectedIndex
-          && (isUsingDefaultFormatComparator()
-              || isTrackSelectable(previousSelectedIndex, effectiveBitrate))
           && bufferedDurationUs >= maxDurationForQualityDecreaseUs) {
         // The selected track is lower priority, but we have sufficient buffer to defer switching
-        // down while preserving existing behavior for default ordering.
+        // down for now.
         newSelectedIndex = previousSelectedIndex;
       }
     }
@@ -604,7 +601,8 @@ public int evaluateQueueSize(long playbackPositionUs, List<? extends MediaChunk>
     if (playoutBufferedDurationBeforeLastChunkUs < minDurationToRetainAfterDiscardUs) {
       return queueSize;
     }
-    int idealSelectedIndex = determineIdealSelectedIndex(nowMs, getLastChunkDurationUs(queue));
+    int idealSelectedIndex =
+        determineIdealSelectedIndex(nowMs, getAllocatedBandwidth(getLastChunkDurationUs(queue)));
     Format idealFormat = getFormat(idealSelectedIndex);
     // If chunks contain video, discard from the first chunk after minDurationToRetainAfterDiscardUs
     // whose resolution and bitrate are both lower than the ideal track, and whose width and height
@@ -676,37 +674,21 @@ protected long getMinDurationToRetainAfterDiscardUs() {
    *
    * @param nowMs The current time in the timebase of {@link Clock#elapsedRealtime()}, or {@link
    *     Long#MIN_VALUE} to ignore track exclusion.
-   * @param chunkDurationUs The duration of a media chunk in microseconds, or {@link C#TIME_UNSET}
-   *     if unknown.
+   * @param effectiveBitrate The bitrate available to this selection.
    */
-  private int determineIdealSelectedIndex(long nowMs, long chunkDurationUs) {
-    return determineIdealSelectedIndexForEffectiveBitrate(nowMs, getAllocatedBandwidth(chunkDurationUs));
-  }
-
-  private int determineIdealSelectedIndexForEffectiveBitrate(long nowMs, long effectiveBitrate) {
-    int lowestBitrateAllowedIndex = C.INDEX_UNSET;
-    int lowestBitrate = Integer.MAX_VALUE;
+  private int determineIdealSelectedIndex(long nowMs, long effectiveBitrate) {
+    int lowestBitrateAllowedIndex = 0;
     for (int i = 0; i < length; i++) {
       if (nowMs == Long.MIN_VALUE || !isTrackExcluded(i, nowMs)) {
         Format format = getFormat(i);
         if (canSelectFormat(format, format.bitrate, effectiveBitrate)) {
           return i;
-        }
-        int formatBitrate = format.bitrate == Format.NO_VALUE ? 0 : format.bitrate;
-        if (formatBitrate <= lowestBitrate) {
-          // fallback semantics by selecting the lowest bitrate non-excluded track when no track
-          // is selectable within available bandwidth.
+        } else {
           lowestBitrateAllowedIndex = i;
-          lowestBitrate = formatBitrate;
         }
       }
     }
-    return lowestBitrateAllowedIndex == C.INDEX_UNSET ? 0 : lowestBitrateAllowedIndex;
-  }
-
-  private boolean isTrackSelectable(int index, long effectiveBitrate) {
-    Format format = getFormat(index);
-    return canSelectFormat(format, format.bitrate, effectiveBitrate);
+    return lowestBitrateAllowedIndex;
   }
 
   private long minDurationForQualityIncreaseUs(long availableDurationUs, long chunkDurationUs) {

libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/BaseTrackSelection.java

@@ -57,9 +57,6 @@ public abstract class BaseTrackSelection implements ExoTrackSelection {
   /** Selected track exclusion timestamps, in selection order. */
   private final long[] excludeUntilTimes;
 
-  /** Whether selected formats are ordered with the default bitrate comparator. */
-  private final boolean isUsingDefaultFormatComparator;
-
   // Lazily initialized hashcode.
   private int hashCode;
 
@@ -103,21 +100,13 @@ protected BaseTrackSelection(
     for (int i = 0; i < tracks.length; i++) {
       formats[i] = group.getFormat(tracks[i]);
     }
-    Comparator<Format> safeFormatComparator = checkNotNull(formatComparator);
-    boolean isUsingDefaultFormatComparator = safeFormatComparator == DEFAULT_FORMAT_COMPARATOR;
-    try {
-      Arrays.sort(formats, safeFormatComparator);
-    } catch (Throwable throwable) {
-      Arrays.sort(formats, DEFAULT_FORMAT_COMPARATOR);
-      isUsingDefaultFormatComparator = true;
-    }
+    Arrays.sort(formats, checkNotNull(formatComparator));
     // Set the format indices in the same order.
     this.tracks = new int[length];
     for (int i = 0; i < length; i++) {
       this.tracks[i] = group.indexOf(formats[i]);
     }
     excludeUntilTimes = new long[length];
-    this.isUsingDefaultFormatComparator = isUsingDefaultFormatComparator;
     playWhenReady = false;
   }
 
@@ -239,11 +228,6 @@ protected final boolean getPlayWhenReady() {
     return playWhenReady;
   }
 
-  /** Returns whether formats are ordered with the default bitrate comparator. */
-  protected final boolean isUsingDefaultFormatComparator() {
-    return isUsingDefaultFormatComparator;
-  }
-
   // Object overrides.
 
   @Override

libraries/exoplayer/src/test/java/androidx/media3/exoplayer/trackselection/AdaptiveTrackSelectionTest.java

@@ -248,7 +248,7 @@ public void initial_updateSelectedTrack_usesFactoryProvidedTrackFormatComparator
   }
 
   @Test
-  public void initial_updateSelectedTrack_withNoSelectableFormat_fallsBackToLowestBitrate() {
+  public void initial_updateSelectedTrack_withNoSelectableFormat_fallsBackToLowestPriorityFormat() {
     Format format1 = videoFormat(/* bitrate= */ 500, /* width= */ 320, /* height= */ 240);
     Format format2 = videoFormat(/* bitrate= */ 1000, /* width= */ 640, /* height= */ 480);
     Format format3 = videoFormat(/* bitrate= */ 2000, /* width= */ 960, /* height= */ 720);
@@ -259,60 +259,7 @@ public void initial_updateSelectedTrack_withNoSelectableFormat_fallsBackToLowest
         prepareAdaptiveTrackSelectionWithFormatComparator(
             trackGroup, formatComparatorInOrder(ImmutableList.of(format2, format1, format3)));
 
-    assertThat(adaptiveTrackSelection.getSelectedFormat()).isEqualTo(format1);
-    assertThat(adaptiveTrackSelection.getSelectionReason()).isEqualTo(C.SELECTION_REASON_INITIAL);
-  }
-
-  @Test
-  public void initial_updateSelectedTrack_withInvalidComparator_fallsBackToDefaultOrdering() {
-    Format format1 = videoFormat(/* bitrate= */ 500, /* width= */ 320, /* height= */ 240);
-    Format format2 = videoFormat(/* bitrate= */ 1000, /* width= */ 640, /* height= */ 480);
-    Format format3 = videoFormat(/* bitrate= */ 2000, /* width= */ 960, /* height= */ 720);
-    TrackGroup trackGroup = new TrackGroup(format1, format2, format3);
-    Comparator<Format> throwingComparator =
-        (firstFormat, secondFormat) -> {
-          throw new RuntimeException("Comparator failure");
-        };
-
-    when(mockBandwidthMeter.getBitrateEstimate()).thenReturn(1000L);
-    AdaptiveTrackSelection adaptiveTrackSelection =
-        prepareAdaptiveTrackSelectionWithFormatComparator(trackGroup, throwingComparator);
-
-    assertThat(adaptiveTrackSelection.getSelectedFormat()).isEqualTo(format2);
-    assertThat(adaptiveTrackSelection.getSelectionReason()).isEqualTo(C.SELECTION_REASON_INITIAL);
-  }
-
-  @Test
-  public void
-      updateSelectedTrack_withInvalidComparator_preservesDefaultDownSwitchDeferralWhenBufferedEnough() {
-    Format format1 = videoFormat(/* bitrate= */ 500, /* width= */ 320, /* height= */ 240);
-    Format format2 = videoFormat(/* bitrate= */ 1000, /* width= */ 640, /* height= */ 480);
-    Format format3 = videoFormat(/* bitrate= */ 2000, /* width= */ 960, /* height= */ 720);
-    TrackGroup trackGroup = new TrackGroup(format1, format2, format3);
-    Comparator<Format> throwingComparator =
-        (firstFormat, secondFormat) -> {
-          throw new RuntimeException("Comparator failure");
-        };
-
-    // The second measurement onward returns 500L, which prompts the track selection to switch down
-    // if necessary.
-    when(mockBandwidthMeter.getBitrateEstimate()).thenReturn(1000L, 500L);
-    AdaptiveTrackSelection adaptiveTrackSelection =
-        prepareAdaptiveTrackSelectionWithFormatComparatorAndDurations(
-            trackGroup,
-            AdaptiveTrackSelection.DEFAULT_MIN_DURATION_FOR_QUALITY_INCREASE_MS,
-            /* maxDurationForQualityDecreaseMs= */ 25_000,
-            throwingComparator);
-
-    adaptiveTrackSelection.updateSelectedTrack(
-        /* playbackPositionUs= */ 0,
-        /* bufferedDurationUs= */ 25_000_000,
-        /* availableDurationUs= */ C.TIME_UNSET,
-        /* queue= */ Collections.emptyList(),
-        createMediaChunkIterators(trackGroup, TEST_CHUNK_DURATION_US));
-
-    // Invalid comparators fall back to the default ordering and preserve the default behavior.
-    assertThat(adaptiveTrackSelection.getSelectedFormat()).isEqualTo(format2);
+    assertThat(adaptiveTrackSelection.getSelectedFormat()).isEqualTo(format3);
     assertThat(adaptiveTrackSelection.getSelectionReason()).isEqualTo(C.SELECTION_REASON_INITIAL);
   }
 
@@ -622,7 +569,7 @@ public void updateSelectedTrack_withCustomFormatOrder_usesCustomOrderForSwitchDi
 
   @Test
   public void
-      updateSelectedTrack_withCustomFormatOrder_switchesDownIfCurrentTrackExceedsBandwidth() {
+      updateSelectedTrack_withCustomFormatOrder_defersSwitchDownWhenBufferedEnough() {
     Format format1 = videoFormat(/* bitrate= */ 500, /* width= */ 320, /* height= */ 240);
     Format format2 = videoFormat(/* bitrate= */ 1000, /* width= */ 640, /* height= */ 480);
     Format format3 = videoFormat(/* bitrate= */ 2000, /* width= */ 960, /* height= */ 720);
@@ -645,8 +592,10 @@ public void updateSelectedTrack_withCustomFormatOrder_usesCustomOrderForSwitchDi
         /* queue= */ Collections.emptyList(),
         createMediaChunkIterators(trackGroup, TEST_CHUNK_DURATION_US));
 
-    assertThat(adaptiveTrackSelection.getSelectedFormat()).isEqualTo(format1);
-    assertThat(adaptiveTrackSelection.getSelectionReason()).isEqualTo(C.SELECTION_REASON_ADAPTIVE);
+    // With sufficient buffer (bufferedDurationUs >= maxDurationForQualityDecreaseUs), the
+    // down-switch is deferred regardless of which comparator is in use.
+    assertThat(adaptiveTrackSelection.getSelectedFormat()).isEqualTo(format2);
+    assertThat(adaptiveTrackSelection.getSelectionReason()).isEqualTo(C.SELECTION_REASON_INITIAL);
   }
 
   @Test