[HLS] Properly handle getNextChunk for a playlist with no segments

When calculating the `segmentIndexInPlaylist` with the binary search (`stayInBound=true`), a corner case of `mediaPlaylist.segments` being empty also lead to the adjusted result of `segmentIndexInPlaylist = 0`. Then in the logic of picking up a `Part`, fetching a `Segment` may end up in `IndexOutOfBoundsException`. Thus we fix the `Part` picking logic into:

* When the playlist is VOD, there is no need to pick up a `Part`, then we bypass the `Part` picking logic;
* When the playlist is LIVE, and we are inside the live window:
  * When the `mediaPlaylist.segments` is not empty, use the old part picking logic: Depending on the `targetPositionInPlaylistUs`, either picking among the `Part`s of an existing `Segment`, or picking among the trailing parts. If we pick among the trailing parts, we should increase the media sequence by one as if we will be loading a "new segment";
  * When the `mediaPlaylist.segments` is empty, we can still try to pick from the trailing parts. If we pick a part, we don't need to increase the media sequence as we have hiddenly increased it by the `stayInBound` adjustment.

As a result, for VOD playlist, an empty `mediaPlaylist.segments` will lead to end of stream, and for LIVE playlist, it will lead to either loading a trailing part or refreshing the playlist.

Issue: #2821
PiperOrigin-RevId: 830887686

Author: tianyif

RELEASENOTES.md

@@ -32,6 +32,8 @@
 *   Cronet extension:
 *   RTMP extension:
 *   HLS extension:
+    *   Properly handle fetching the next chunk for an `HlsMediaPlaylist` with
+        no segments ([#2821](https://github.com/androidx/media/issues/2821)).
 *   DASH extension:
 *   Smooth Streaming extension:
 *   RTSP extension:

libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsChunkSource.java

@@ -905,20 +905,36 @@ private Pair<Long, Integer> getNextMediaSequenceAndPartIndex(
               /* stayInBounds= */ !playlistTracker.isLive() || previous == null);
       long mediaSequence = segmentIndexInPlaylist + mediaPlaylist.mediaSequence;
       int partIndex = C.INDEX_UNSET;
+      if (!playlistTracker.isLive()) {
+        // Early return as we don't need to pick a part for VOD.
+        return new Pair<>(mediaSequence, partIndex);
+      }
+
       if (segmentIndexInPlaylist >= 0) {
         // In case we are inside the live window, we try to pick a part if available.
-        Segment segment = mediaPlaylist.segments.get(segmentIndexInPlaylist);
-        List<HlsMediaPlaylist.Part> parts =
-            targetPositionInPlaylistUs < segment.relativeStartTimeUs + segment.durationUs
-                ? segment.parts
-                : mediaPlaylist.trailingParts;
+        List<HlsMediaPlaylist.Part> parts;
+        if (!mediaPlaylist.segments.isEmpty()) {
+          Segment segment = mediaPlaylist.segments.get(segmentIndexInPlaylist);
+          parts =
+              targetPositionInPlaylistUs < segment.relativeStartTimeUs + segment.durationUs
+                  ? segment.parts
+                  : mediaPlaylist.trailingParts;
+        } else {
+          // There are no full segments in the playlist, but we can still pick a trailing part.
+          parts = mediaPlaylist.trailingParts;
+        }
         for (int i = 0; i < parts.size(); i++) {
           HlsMediaPlaylist.Part part = parts.get(i);
           if (targetPositionInPlaylistUs < part.relativeStartTimeUs + part.durationUs) {
             if (part.isIndependent) {
               partIndex = i;
-              // Increase media sequence by one if the part is a trailing part.
-              mediaSequence += parts == mediaPlaylist.trailingParts ? 1 : 0;
+              // Increase media sequence by one if the part is a trailing part and
+              // mediaPlaylist.segments is not empty. When mediaPlaylist.segments is empty, the
+              // media sequence has already been increased by the stay-in-bound adjustment.
+              mediaSequence +=
+                  (parts == mediaPlaylist.trailingParts && !mediaPlaylist.segments.isEmpty())
+                      ? 1
+                      : 0;
             }
             break;
           }

libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsChunkSourceTest.java

@@ -78,6 +78,10 @@ public class HlsChunkSourceTest {
       "media/m3u8/live_low_latency_segments_and_parts";
   private static final String PLAYLIST_LIVE_LOW_LATENCY_SEGMENTS_AND_SINGLE_PRELOAD_PART =
       "media/m3u8/live_low_latency_segments_and_single_preload_part";
+  private static final String PLAYLIST_VOD_EMPTY = "media/m3u8/media_playlist_vod_empty";
+  private static final String PLAYLIST_LIVE_EMPTY = "media/m3u8/media_playlist_live_empty";
+  private static final String PLAYLIST_LIVE_LOW_LATENCY_PARTS_ONLY =
+      "media/m3u8/live_low_latency_parts_only";
   private static final Uri PLAYLIST_URI = Uri.parse("http://example.com/");
   private static final Uri PLAYLIST_URI_2 = Uri.parse("http://example2.com/");
   private static final long PLAYLIST_START_PERIOD_OFFSET_US = 8_000_000L;
@@ -337,6 +341,94 @@ public void getNextChunk_chunkSourceWithDefaultCmcdConfiguration_setsCorrectBuff
     assertThat(output.chunk.dataSpec.httpRequestHeaders).doesNotContainKey("CMCD-Status");
   }
 
+  @Test
+  public void getNextChunk_forEmptyVodPlaylist_getsNullChunkAndInferEndOfStream()
+      throws IOException {
+    HlsChunkSource testChunkSource = createHlsChunkSource(PLAYLIST_VOD_EMPTY);
+    HlsChunkSource.HlsChunkHolder output = new HlsChunkSource.HlsChunkHolder();
+
+    testChunkSource.getNextChunk(
+        new LoadingInfo.Builder().setPlaybackPositionUs(9_000_000).setPlaybackSpeed(1.0f).build(),
+        /* loadPositionUs= */ 9_000_000,
+        /* largestReadPositionUs= */ 0,
+        /* queue= */ ImmutableList.of(),
+        /* allowEndOfStream= */ true,
+        output);
+
+    assertThat(output.chunk).isNull();
+    assertThat(output.endOfStream).isTrue();
+  }
+
+  @Test
+  public void getNextChunk_forEmptyLivePlaylist_getsNullChunkAndInferReloadingPlaylist()
+      throws IOException {
+    HlsChunkSource testChunkSource = createHlsChunkSource(PLAYLIST_LIVE_EMPTY);
+    HlsChunkSource.HlsChunkHolder output = new HlsChunkSource.HlsChunkHolder();
+
+    testChunkSource.getNextChunk(
+        new LoadingInfo.Builder().setPlaybackPositionUs(9_000_000).setPlaybackSpeed(1.0f).build(),
+        /* loadPositionUs= */ 9_000_000,
+        /* largestReadPositionUs= */ 0,
+        /* queue= */ ImmutableList.of(),
+        /* allowEndOfStream= */ true,
+        output);
+
+    assertThat(output.chunk).isNull();
+    assertThat(output.playlistUrl).isEqualTo(PLAYLIST_URI);
+    assertThat(output.endOfStream).isFalse();
+  }
+
+  @Test
+  public void getNextChunk_forLivePlaylistWithSegmentsAndParts_getsCorrectChunk()
+      throws IOException {
+    HlsChunkSource testChunkSource =
+        createHlsChunkSource(PLAYLIST_LIVE_LOW_LATENCY_SEGMENTS_AND_PARTS);
+    HlsChunkSource.HlsChunkHolder output = new HlsChunkSource.HlsChunkHolder();
+
+    testChunkSource.getNextChunk(
+        new LoadingInfo.Builder().setPlaybackPositionUs(28_000_000).setPlaybackSpeed(1.0f).build(),
+        /* loadPositionUs= */ 28_000_000,
+        /* largestReadPositionUs= */ 0,
+        /* queue= */ ImmutableList.of(),
+        /* allowEndOfStream= */ true,
+        output);
+
+    // Gets a chunk from an independent segment part.
+    Uri expectedDataSpecUri = Uri.parse("http://example.com/fileSequence15.0.ts");
+    assertThat(output.chunk.dataSpec.uri).isEqualTo(expectedDataSpecUri);
+
+    testChunkSource.getNextChunk(
+        new LoadingInfo.Builder().setPlaybackPositionUs(32_000_000).setPlaybackSpeed(1.0f).build(),
+        /* loadPositionUs= */ 32_000_000,
+        /* largestReadPositionUs= */ 0,
+        /* queue= */ ImmutableList.of(),
+        /* allowEndOfStream= */ true,
+        output);
+
+    // Gets a chunk from an independent trailing part.
+    expectedDataSpecUri = Uri.parse("http://example.com/fileSequence16.0.ts");
+    assertThat(output.chunk.dataSpec.uri).isEqualTo(expectedDataSpecUri);
+  }
+
+  @Test
+  public void getNextChunk_forLivePlaylistWithPartsOnly_getsCorrectChunkFromParts()
+      throws IOException {
+    HlsChunkSource testChunkSource = createHlsChunkSource(PLAYLIST_LIVE_LOW_LATENCY_PARTS_ONLY);
+    HlsChunkSource.HlsChunkHolder output = new HlsChunkSource.HlsChunkHolder();
+
+    // A request to fetch the chunk at 8 seconds should retrieve the first part.
+    testChunkSource.getNextChunk(
+        new LoadingInfo.Builder().setPlaybackPositionUs(8_000_000).setPlaybackSpeed(1.0f).build(),
+        /* loadPositionUs= */ 8_000_000,
+        /* largestReadPositionUs= */ 0,
+        /* queue= */ ImmutableList.of(),
+        /* allowEndOfStream= */ true,
+        output);
+
+    Uri expectedDataSpecUri = Uri.parse("http://example.com/fileSequence16.0.ts");
+    assertThat(output.chunk.dataSpec.uri).isEqualTo(expectedDataSpecUri);
+  }
+
   @Test
   public void getNextChunk_forLivePlaylistWithSegmentsOnly_setsCorrectNextObjectRequest()
       throws IOException {
@@ -949,6 +1041,7 @@ private static HlsChunkSource createHlsChunkSource(
       when(mockPlaylistTracker.getPlaylistSnapshot(eq(playlistUri), anyBoolean()))
           .thenReturn(playlist);
       when(mockPlaylistTracker.isSnapshotValid(eq(playlistUri))).thenReturn(true);
+      when(mockPlaylistTracker.isLive()).thenAnswer(invocation -> !playlist.hasEndTag);
       if (playlistLoadException != null) {
         doThrow(playlistLoadException)
             .when(mockPlaylistTracker)

libraries/test_data/src/test/assets/media/m3u8/live_low_latency_parts_only

@@ -0,0 +1,9 @@
+#EXTM3U
+#EXT-X-TARGETDURATION:4
+#EXT-X-INDEPENDENT-SEGMENTS
+#EXT-X-PART-INF:PART-TARGET=1.000400
+#EXT-X-VERSION:3
+#EXT-X-MEDIA-SEQUENCE:10
+#EXT-X-PART:DURATION=1.00000,URI="fileSequence16.0.ts"
+#EXT-X-PART:DURATION=1.00000,URI="fileSequence16.1.ts"
+#EXT-X-PRELOAD-HINT:TYPE=PART,URI="fileSequence16.2.ts"

libraries/test_data/src/test/assets/media/m3u8/media_playlist_live_empty

@@ -0,0 +1,3 @@
+#EXTM3U
+#EXT-X-MEDIA-SEQUENCE:2
+#EXT-X-MAP:URI="init.mp4"

libraries/test_data/src/test/assets/media/m3u8/media_playlist_vod_empty

@@ -0,0 +1,4 @@
+#EXTM3U
+#EXT-X-MEDIA-SEQUENCE:2
+#EXT-X-MAP:URI="init.mp4"
+#EXT-X-ENDLIST