Fix timestamps across concatenated TSes

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

@@ -271,7 +271,7 @@ public synchronized boolean isInitialized() {
    * @return The corresponding value in microseconds.
    */
   public static long ptsToUs(long pts) {
-    return (pts * C.MICROS_PER_SECOND) / 90000;
+    return Math.round((double)pts * C.MICROS_PER_SECOND / 90000);
   }
 
   /**

libraries/extractor/src/main/java/androidx/media3/extractor/ts/TsBinarySearchSeeker.java

@@ -28,25 +28,25 @@
 /**
  * A seeker that supports seeking within TS stream using binary search.
  *
- * <p>This seeker uses the first and last PCR values within the stream, as well as the stream
- * duration to interpolate the PCR value of the seeking position. Then it performs binary search
- * within the stream to find a packets whose PCR value is within {@link #SEEK_TOLERANCE_US} from the
- * target PCR.
+ * <p>This seeker uses the first and last DTS values within the stream, as well as the stream
+ * duration to interpolate the DTS value of the seeking position. Then it performs binary search
+ * within the stream to find a packets whose DTS value is within {@link #SEEK_TOLERANCE_US} from the
+ * target DTS.
  */
 /* package */ final class TsBinarySearchSeeker extends BinarySearchSeeker {
 
   private static final long SEEK_TOLERANCE_US = 100_000;
   private static final int MINIMUM_SEARCH_RANGE_BYTES = 5 * TsExtractor.TS_PACKET_SIZE;
 
   public TsBinarySearchSeeker(
-      TimestampAdjuster pcrTimestampAdjuster,
+      TimestampAdjuster timestampAdjuster,
       long streamDurationUs,
       long inputLength,
-      int pcrPid,
+      int selectedPid,
       int timestampSearchBytes) {
     super(
         new DefaultSeekTimestampConverter(),
-        new TsPcrSeeker(pcrPid, pcrTimestampAdjuster, timestampSearchBytes),
+        new TsTimestampSeeker(selectedPid, timestampAdjuster, timestampSearchBytes),
         streamDurationUs,
         /* floorTimePosition= */ 0,
         /* ceilingTimePosition= */ streamDurationUs + 1,
@@ -57,25 +57,25 @@ public TsBinarySearchSeeker(
   }
 
   /**
-   * A {@link TimestampSeeker} implementation that looks for a given PCR timestamp at a given
+   * A {@link TimestampSeeker} implementation that looks for a given DTS timestamp at a given
    * position in a TS stream.
    *
-   * <p>Given a PCR timestamp, and a position within a TS stream, this seeker will peek up to {@link
+   * <p>Given a DTS timestamp, and a position within a TS stream, this seeker will peek up to {@link
    * #timestampSearchBytes} from that stream position, look for all packets with PID equal to
-   * PCR_PID, and then compare the PCR timestamps (if available) of these packets to the target
+   * SELECTED_PID, and then compare the DTS timestamps (if available) of these packets to the target
    * timestamp.
    */
-  private static final class TsPcrSeeker implements TimestampSeeker {
+  private static final class TsTimestampSeeker implements TimestampSeeker {
 
-    private final TimestampAdjuster pcrTimestampAdjuster;
+    private final TimestampAdjuster timestampAdjuster;
     private final ParsableByteArray packetBuffer;
-    private final int pcrPid;
+    private final int selectedPid;
     private final int timestampSearchBytes;
 
-    public TsPcrSeeker(
-        int pcrPid, TimestampAdjuster pcrTimestampAdjuster, int timestampSearchBytes) {
-      this.pcrPid = pcrPid;
-      this.pcrTimestampAdjuster = pcrTimestampAdjuster;
+    public TsTimestampSeeker(
+        int selectedPid, TimestampAdjuster timestampAdjuster, int timestampSearchBytes) {
+      this.selectedPid = selectedPid;
+      this.timestampAdjuster = timestampAdjuster;
       this.timestampSearchBytes = timestampSearchBytes;
       packetBuffer = new ParsableByteArray();
     }
@@ -89,16 +89,16 @@ public TimestampSearchResult searchForTimestamp(ExtractorInput input, long targe
       packetBuffer.reset(bytesToSearch);
       input.peekFully(packetBuffer.getData(), /* offset= */ 0, bytesToSearch);
 
-      return searchForPcrValueInBuffer(packetBuffer, targetTimestamp, inputPosition);
+      return searchForDtsValueInBuffer(packetBuffer, targetTimestamp, inputPosition);
     }
 
-    private TimestampSearchResult searchForPcrValueInBuffer(
-        ParsableByteArray packetBuffer, long targetPcrTimeUs, long bufferStartOffset) {
+    private TimestampSearchResult searchForDtsValueInBuffer(
+        ParsableByteArray packetBuffer, long targetDtsTimeUs, long bufferStartOffset) {
       int limit = packetBuffer.limit();
 
       long startOfLastPacketPosition = C.INDEX_UNSET;
       long endOfLastPacketPosition = C.INDEX_UNSET;
-      long lastPcrTimeUsInRange = C.TIME_UNSET;
+      long lastDtsTimeUsInRange = C.TIME_UNSET;
 
       while (packetBuffer.bytesLeft() >= TsExtractor.TS_PACKET_SIZE) {
         int startOfPacket =
@@ -107,34 +107,34 @@ private TimestampSearchResult searchForPcrValueInBuffer(
         if (endOfPacket > limit) {
           break;
         }
-        long pcrValue = TsUtil.readPcrFromPacket(packetBuffer, startOfPacket, pcrPid);
-        if (pcrValue != C.TIME_UNSET) {
-          long pcrTimeUs = pcrTimestampAdjuster.adjustTsTimestamp(pcrValue);
-          if (pcrTimeUs > targetPcrTimeUs) {
-            if (lastPcrTimeUsInRange == C.TIME_UNSET) {
-              // First PCR timestamp is already over target.
-              return TimestampSearchResult.overestimatedResult(pcrTimeUs, bufferStartOffset);
+        long dtsValue = TsUtil.readDtsFromPacket(packetBuffer, startOfPacket, selectedPid);
+        if (dtsValue != C.TIME_UNSET) {
+          long dtsTimeUs = timestampAdjuster.adjustTsTimestamp(dtsValue);
+          if (dtsTimeUs > targetDtsTimeUs) {
+            if (lastDtsTimeUsInRange == C.TIME_UNSET) {
+              // First DTS timestamp is already over target.
+              return TimestampSearchResult.overestimatedResult(dtsTimeUs, bufferStartOffset);
             } else {
-              // Last PCR timestamp < target timestamp < this timestamp.
+              // Last DTS timestamp < target timestamp < this timestamp.
               return TimestampSearchResult.targetFoundResult(
                   bufferStartOffset + startOfLastPacketPosition);
             }
-          } else if (pcrTimeUs + SEEK_TOLERANCE_US > targetPcrTimeUs) {
+          } else if (dtsTimeUs + SEEK_TOLERANCE_US > targetDtsTimeUs) {
             long startOfPacketInStream = bufferStartOffset + startOfPacket;
             return TimestampSearchResult.targetFoundResult(startOfPacketInStream);
           }
 
-          lastPcrTimeUsInRange = pcrTimeUs;
+          lastDtsTimeUsInRange = dtsTimeUs;
           startOfLastPacketPosition = startOfPacket;
         }
         packetBuffer.setPosition(endOfPacket);
         endOfLastPacketPosition = endOfPacket;
       }
 
-      if (lastPcrTimeUsInRange != C.TIME_UNSET) {
+      if (lastDtsTimeUsInRange != C.TIME_UNSET) {
         long endOfLastPacketPositionInStream = bufferStartOffset + endOfLastPacketPosition;
         return TimestampSearchResult.underestimatedResult(
-            lastPcrTimeUsInRange, endOfLastPacketPositionInStream);
+            lastDtsTimeUsInRange, endOfLastPacketPositionInStream);
       } else {
         return TimestampSearchResult.NO_TIMESTAMP_IN_RANGE_RESULT;
       }