Refactored and added Javadoc

Author: rohitjoins

RELEASENOTES.md

@@ -11,8 +11,8 @@
         variable bitrate metadata when falling back to constant bitrate seeking
         due to `FLAG_ENABLE_CONSTANT_BITRATE_SEEKING(_ALWAYS)`
         ([#2194](https://github.com/androidx/media/issues/2194)).
-    *   Fix seek on fragmented mp4 with multiple sidx atoms.
-        ([#9373](https://github.com/google/ExoPlayer/issues/9373))
+    *   Add support for seeking in fragmented MP4 with multiple `sidx` atoms
+        ([#9373](https://github.com/google/ExoPlayer/issues/9373)).
 *   DataSource:
 *   Audio:
     *   Allow constant power upmixing/downmixing in DefaultAudioMixer.

libraries/common/src/main/java/androidx/media3/common/util/Util.java

@@ -703,6 +703,54 @@ public static <T> void nullSafeListToArray(List<T> list, T[] array) {
     list.toArray(array);
   }
 
+  /**
+   * Creates a new array containing the concatenation of multiple non-null {@code int[]} arrays.
+   *
+   * @param arrays A list of non-null {@code int[]} arrays to concatenate.
+   * @return The concatenated result.
+   */
+  @UnstableApi
+  public static int[] nullSafeIntArraysConcatenation(List<int[]> arrays) {
+    int totalLength = 0;
+    for (int[] array : arrays) {
+      totalLength += array.length;
+    }
+
+    int[] concatenation = new int[totalLength];
+
+    int offset = 0;
+    for (int[] array : arrays) {
+      System.arraycopy(array, 0, concatenation, offset, array.length);
+      offset += array.length;
+    }
+
+    return concatenation;
+  }
+
+  /**
+   * Creates a new array containing the concatenation of multiple non-null {@code long[]} arrays.
+   *
+   * @param arrays A list of non-null {@code long[]} arrays to concatenate.
+   * @return The concatenated result.
+   */
+  @UnstableApi
+  public static long[] nullSafeLongArraysConcatenation(List<long[]> arrays) {
+    int totalLength = 0;
+    for (long[] array : arrays) {
+      totalLength += array.length;
+    }
+
+    long[] res = new long[totalLength];
+
+    int offset = 0;
+    for (long[] array : arrays) {
+      System.arraycopy(array, 0, res, offset, array.length);
+      offset += array.length;
+    }
+
+    return res;
+  }
+
   /**
    * Creates a {@link Handler} on the current {@link Looper} thread.
    *

libraries/extractor/src/main/java/androidx/media3/extractor/ChunkIndicesWrapper.java

@@ -0,0 +1,92 @@
+/*
+ * Copyright 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.extractor;
+
+import androidx.media3.common.util.UnstableApi;
+import androidx.media3.common.util.Util;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * A utility class for merging multiple {@link ChunkIndex} instances into a single {@link
+ * ChunkIndex}.
+ *
+ * <p>This is useful in scenarios where media is split across multiple segments or sources, and a
+ * unified index is needed for seeking or playback.
+ */
+@UnstableApi
+public class MergedChunkIndex {
+
+  /** The individual {@link ChunkIndex} entries being merged. */
+  private final List<ChunkIndex> chunks;
+
+  /** The set of first start times seen so far across added {@link ChunkIndex} instances. */
+  private final Set<Long> uniqueStartTimes;
+
+  /** Creates an instance. */
+  public MergedChunkIndex() {
+    this.chunks = new ArrayList<>();
+    this.uniqueStartTimes = new HashSet<>();
+  }
+
+  /**
+   * Adds a {@link ChunkIndex} to be merged.
+   *
+   * <p>Chunk indices with duplicate starting timestamps are ignored to avoid redundant data.
+   *
+   * @param chunk The {@link ChunkIndex} to add.
+   */
+  public void merge(ChunkIndex chunk) {
+    if (chunk.timesUs.length > 0 && !uniqueStartTimes.contains(chunk.timesUs[0])) {
+      chunks.add(chunk);
+      uniqueStartTimes.add(chunk.timesUs[0]);
+    }
+  }
+
+  /** Returns a single {@link ChunkIndex} that combines all added chunk indices. */
+  public ChunkIndex toChunkIndex() {
+    List<int[]> sizesList = new ArrayList<>();
+    List<long[]> offsetsList = new ArrayList<>();
+    List<long[]> durationsList = new ArrayList<>();
+    List<long[]> timesList = new ArrayList<>();
+
+    for (ChunkIndex chunk : chunks) {
+      sizesList.add(chunk.sizes);
+      offsetsList.add(chunk.offsets);
+      durationsList.add(chunk.durationsUs);
+      timesList.add(chunk.timesUs);
+    }
+
+    return new ChunkIndex(
+        Util.nullSafeIntArraysConcatenation(sizesList),
+        Util.nullSafeLongArraysConcatenation(offsetsList),
+        Util.nullSafeLongArraysConcatenation(durationsList),
+        Util.nullSafeLongArraysConcatenation(timesList));
+  }
+
+  /** Clears all added chunk indices and internal state. */
+  public void clear() {
+    chunks.clear();
+    uniqueStartTimes.clear();
+  }
+
+  /** Returns the number of chunk indices added so far. */
+  public int size() {
+    return chunks.size();
+  }
+}