Automated g4 rollback of changelist 190906020.

*** Reason for rollback ***

Breaks looping.

*** Original change description ***

Automated g4 rollback of changelist 190628272.

*** Reason for rollback ***

b/76391022 was caused by a timestamp correction in StabilizableSimpleExoPlayer which will be fixed with this CL.

*** Original change description ***

Automated g4 rollback of changelist 189570277.

*** Reason for rollback ***

causes b/76391022, motion still playback in Photos is broken

*** Original change description ***

Used fixed time frame in clipping media period.

Currently, whenever the clipping is updated, we...

***

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

library/core/src/main/java/com/google/android/exoplayer2/MediaPeriodHolder.java

@@ -83,12 +83,9 @@ import com.google.android.exoplayer2.util.Assertions;
     mayRetainStreamFlags = new boolean[rendererCapabilities.length];
     mayRetainStreamFlags = new boolean[rendererCapabilities.length];
     MediaPeriod mediaPeriod = mediaSource.createPeriod(info.id, allocator);
     MediaPeriod mediaPeriod = mediaSource.createPeriod(info.id, allocator);
     if (info.endPositionUs != C.TIME_END_OF_SOURCE) {
     if (info.endPositionUs != C.TIME_END_OF_SOURCE) {
-      mediaPeriod =
-          new ClippingMediaPeriod(
-              mediaPeriod,
-              /* enableInitialDiscontinuity= */ true,
-              /* startUs= */ 0,
-              info.endPositionUs);
+      ClippingMediaPeriod clippingMediaPeriod = new ClippingMediaPeriod(mediaPeriod, true);
+      clippingMediaPeriod.setClipping(0, info.endPositionUs);
+      mediaPeriod = clippingMediaPeriod;
     }
     }
     this.mediaPeriod = mediaPeriod;
     this.mediaPeriod = mediaPeriod;
   }
   }

library/core/src/main/java/com/google/android/exoplayer2/source/ClippingMediaPeriod.java

@@ -23,7 +23,6 @@ import com.google.android.exoplayer2.decoder.DecoderInputBuffer;
 import com.google.android.exoplayer2.trackselection.TrackSelection;
 import com.google.android.exoplayer2.trackselection.TrackSelection;
 import com.google.android.exoplayer2.util.Assertions;
 import com.google.android.exoplayer2.util.Assertions;
 import com.google.android.exoplayer2.util.MimeTypes;
 import com.google.android.exoplayer2.util.MimeTypes;
-import com.google.android.exoplayer2.util.Util;
 import java.io.IOException;
 import java.io.IOException;
 
 
 /**
 /**
@@ -44,36 +43,35 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
   /* package */ long endUs;
   /* package */ long endUs;
 
 
   /**
   /**
-   * Creates a new clipping media period that provides a clipped view of the specified {@link
-   * MediaPeriod}'s sample streams.
-   *
-   * <p>If the start point is guaranteed to be a key frame, pass {@code false} to {@code
+   * Creates a new clipping media period that provides a clipped view of the specified
+   * {@link MediaPeriod}'s sample streams.
+   * <p>
+   * The clipping start/end positions must be specified by calling {@link #setClipping(long, long)}
+   * on the playback thread before preparation completes.
+   * <p>
+   * If the start point is guaranteed to be a key frame, pass {@code false} to {@code
    * enableInitialPositionDiscontinuity} to suppress an initial discontinuity when the period is
    * enableInitialPositionDiscontinuity} to suppress an initial discontinuity when the period is
    * first read from.
    * first read from.
    *
    *
    * @param mediaPeriod The media period to clip.
    * @param mediaPeriod The media period to clip.
    * @param enableInitialDiscontinuity Whether the initial discontinuity should be enabled.
    * @param enableInitialDiscontinuity Whether the initial discontinuity should be enabled.
-   * @param startUs The clipping start time, in microseconds.
-   * @param endUs The clipping end time, in microseconds, or {@link C#TIME_END_OF_SOURCE} to
-   *     indicate the end of the period.
    */
    */
-  public ClippingMediaPeriod(
-      MediaPeriod mediaPeriod, boolean enableInitialDiscontinuity, long startUs, long endUs) {
+  public ClippingMediaPeriod(MediaPeriod mediaPeriod, boolean enableInitialDiscontinuity) {
     this.mediaPeriod = mediaPeriod;
     this.mediaPeriod = mediaPeriod;
     sampleStreams = new ClippingSampleStream[0];
     sampleStreams = new ClippingSampleStream[0];
-    pendingInitialDiscontinuityPositionUs = enableInitialDiscontinuity ? startUs : C.TIME_UNSET;
-    this.startUs = startUs;
-    this.endUs = endUs;
+    pendingInitialDiscontinuityPositionUs = enableInitialDiscontinuity ? 0 : C.TIME_UNSET;
+    startUs = C.TIME_UNSET;
+    endUs = C.TIME_UNSET;
   }
   }
 
 
   /**
   /**
-   * Updates the clipping start/end times for this period, in microseconds.
+   * Sets the clipping start/end times for this period, in microseconds.
    *
    *
    * @param startUs The clipping start time, in microseconds.
    * @param startUs The clipping start time, in microseconds.
    * @param endUs The clipping end time, in microseconds, or {@link C#TIME_END_OF_SOURCE} to
    * @param endUs The clipping end time, in microseconds, or {@link C#TIME_END_OF_SOURCE} to
    *     indicate the end of the period.
    *     indicate the end of the period.
    */
    */
-  public void updateClipping(long startUs, long endUs) {
+  public void setClipping(long startUs, long endUs) {
     this.startUs = startUs;
     this.startUs = startUs;
     this.endUs = endUs;
     this.endUs = endUs;
   }
   }
@@ -81,7 +79,7 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
   @Override
   @Override
   public void prepare(MediaPeriod.Callback callback, long positionUs) {
   public void prepare(MediaPeriod.Callback callback, long positionUs) {
     this.callback = callback;
     this.callback = callback;
-    mediaPeriod.prepare(this, positionUs);
+    mediaPeriod.prepare(this, startUs + positionUs);
   }
   }
 
 
   @Override
   @Override
@@ -103,19 +101,13 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
       sampleStreams[i] = (ClippingSampleStream) streams[i];
       sampleStreams[i] = (ClippingSampleStream) streams[i];
       childStreams[i] = sampleStreams[i] != null ? sampleStreams[i].childStream : null;
       childStreams[i] = sampleStreams[i] != null ? sampleStreams[i].childStream : null;
     }
     }
-    long enablePositionUs =
-        mediaPeriod.selectTracks(
-            selections, mayRetainStreamFlags, childStreams, streamResetFlags, positionUs);
-    pendingInitialDiscontinuityPositionUs =
-        isPendingInitialDiscontinuity()
-                && positionUs == startUs
-                && shouldKeepInitialDiscontinuity(startUs, selections)
-            ? enablePositionUs
-            : C.TIME_UNSET;
-    Assertions.checkState(
-        enablePositionUs == positionUs
-            || (enablePositionUs >= startUs
-                && (endUs == C.TIME_END_OF_SOURCE || enablePositionUs <= endUs)));
+    long enablePositionUs = mediaPeriod.selectTracks(selections, mayRetainStreamFlags,
+        childStreams, streamResetFlags, positionUs + startUs) - startUs;
+    pendingInitialDiscontinuityPositionUs = isPendingInitialDiscontinuity() && positionUs == 0
+        && shouldKeepInitialDiscontinuity(startUs, selections) ? enablePositionUs : C.TIME_UNSET;
+    Assertions.checkState(enablePositionUs == positionUs
+        || (enablePositionUs >= 0
+        && (endUs == C.TIME_END_OF_SOURCE || startUs + enablePositionUs <= endUs)));
     for (int i = 0; i < streams.length; i++) {
     for (int i = 0; i < streams.length; i++) {
       if (childStreams[i] == null) {
       if (childStreams[i] == null) {
         sampleStreams[i] = null;
         sampleStreams[i] = null;
@@ -129,12 +121,12 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
 
 
   @Override
   @Override
   public void discardBuffer(long positionUs, boolean toKeyframe) {
   public void discardBuffer(long positionUs, boolean toKeyframe) {
-    mediaPeriod.discardBuffer(positionUs, toKeyframe);
+    mediaPeriod.discardBuffer(positionUs + startUs, toKeyframe);
   }
   }
 
 
   @Override
   @Override
   public void reevaluateBuffer(long positionUs) {
   public void reevaluateBuffer(long positionUs) {
-    mediaPeriod.reevaluateBuffer(positionUs);
+    mediaPeriod.reevaluateBuffer(positionUs + startUs);
   }
   }
 
 
   @Override
   @Override
@@ -152,7 +144,7 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
     }
     }
     Assertions.checkState(discontinuityUs >= startUs);
     Assertions.checkState(discontinuityUs >= startUs);
     Assertions.checkState(endUs == C.TIME_END_OF_SOURCE || discontinuityUs <= endUs);
     Assertions.checkState(endUs == C.TIME_END_OF_SOURCE || discontinuityUs <= endUs);
-    return discontinuityUs;
+    return discontinuityUs - startUs;
   }
   }
 
 
   @Override
   @Override
@@ -162,7 +154,7 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
         || (endUs != C.TIME_END_OF_SOURCE && bufferedPositionUs >= endUs)) {
         || (endUs != C.TIME_END_OF_SOURCE && bufferedPositionUs >= endUs)) {
       return C.TIME_END_OF_SOURCE;
       return C.TIME_END_OF_SOURCE;
     }
     }
-    return bufferedPositionUs;
+    return Math.max(0, bufferedPositionUs - startUs);
   }
   }
 
 
   @Override
   @Override
@@ -173,21 +165,23 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
         sampleStream.clearSentEos();
         sampleStream.clearSentEos();
       }
       }
     }
     }
-    long seekUs = mediaPeriod.seekToUs(positionUs);
+    long offsetPositionUs = positionUs + startUs;
+    long seekUs = mediaPeriod.seekToUs(offsetPositionUs);
     Assertions.checkState(
     Assertions.checkState(
-        seekUs == positionUs
+        seekUs == offsetPositionUs
             || (seekUs >= startUs && (endUs == C.TIME_END_OF_SOURCE || seekUs <= endUs)));
             || (seekUs >= startUs && (endUs == C.TIME_END_OF_SOURCE || seekUs <= endUs)));
-    return seekUs;
+    return seekUs - startUs;
   }
   }
 
 
   @Override
   @Override
   public long getAdjustedSeekPositionUs(long positionUs, SeekParameters seekParameters) {
   public long getAdjustedSeekPositionUs(long positionUs, SeekParameters seekParameters) {
-    if (positionUs == startUs) {
+    if (positionUs == 0) {
       // Never adjust seeks to the start of the clipped view.
       // Never adjust seeks to the start of the clipped view.
-      return startUs;
+      return 0;
     }
     }
-    SeekParameters clippedSeekParameters = clipSeekParameters(positionUs, seekParameters);
-    return mediaPeriod.getAdjustedSeekPositionUs(positionUs, clippedSeekParameters);
+    long offsetPositionUs = positionUs + startUs;
+    SeekParameters clippedSeekParameters = clipSeekParameters(offsetPositionUs, seekParameters);
+    return mediaPeriod.getAdjustedSeekPositionUs(offsetPositionUs, clippedSeekParameters) - startUs;
   }
   }
 
 
   @Override
   @Override
@@ -197,18 +191,19 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
         || (endUs != C.TIME_END_OF_SOURCE && nextLoadPositionUs >= endUs)) {
         || (endUs != C.TIME_END_OF_SOURCE && nextLoadPositionUs >= endUs)) {
       return C.TIME_END_OF_SOURCE;
       return C.TIME_END_OF_SOURCE;
     }
     }
-    return nextLoadPositionUs;
+    return nextLoadPositionUs - startUs;
   }
   }
 
 
   @Override
   @Override
   public boolean continueLoading(long positionUs) {
   public boolean continueLoading(long positionUs) {
-    return mediaPeriod.continueLoading(positionUs);
+    return mediaPeriod.continueLoading(positionUs + startUs);
   }
   }
 
 
   // MediaPeriod.Callback implementation.
   // MediaPeriod.Callback implementation.
 
 
   @Override
   @Override
   public void onPrepared(MediaPeriod mediaPeriod) {
   public void onPrepared(MediaPeriod mediaPeriod) {
+    Assertions.checkState(startUs != C.TIME_UNSET && endUs != C.TIME_UNSET);
     callback.onPrepared(this);
     callback.onPrepared(this);
   }
   }
 
 
@@ -221,20 +216,17 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
     return pendingInitialDiscontinuityPositionUs != C.TIME_UNSET;
     return pendingInitialDiscontinuityPositionUs != C.TIME_UNSET;
   }
   }
 
 
-  private SeekParameters clipSeekParameters(long positionUs, SeekParameters seekParameters) {
-    long toleranceBeforeUs =
-        Util.constrainValue(
-            seekParameters.toleranceBeforeUs, /* min= */ 0, /* max= */ positionUs - startUs);
-    long toleranceAfterUs =
-        Util.constrainValue(
-            seekParameters.toleranceAfterUs,
-            /* min= */ 0,
-            /* max= */ endUs == C.TIME_END_OF_SOURCE ? Long.MAX_VALUE : endUs - positionUs);
-    if (toleranceBeforeUs == seekParameters.toleranceBeforeUs
-        && toleranceAfterUs == seekParameters.toleranceAfterUs) {
+  private SeekParameters clipSeekParameters(long offsetPositionUs, SeekParameters seekParameters) {
+    long toleranceBeforeMs = Math.min(offsetPositionUs - startUs, seekParameters.toleranceBeforeUs);
+    long toleranceAfterMs =
+        endUs == C.TIME_END_OF_SOURCE
+            ? seekParameters.toleranceAfterUs
+            : Math.min(endUs - offsetPositionUs, seekParameters.toleranceAfterUs);
+    if (toleranceBeforeMs == seekParameters.toleranceBeforeUs
+        && toleranceAfterMs == seekParameters.toleranceAfterUs) {
       return seekParameters;
       return seekParameters;
     } else {
     } else {
-      return new SeekParameters(toleranceBeforeUs, toleranceAfterUs);
+      return new SeekParameters(toleranceBeforeMs, toleranceAfterMs);
     }
     }
   }
   }
 
 
@@ -318,6 +310,9 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
         sentEos = true;
         sentEos = true;
         return C.RESULT_BUFFER_READ;
         return C.RESULT_BUFFER_READ;
       }
       }
+      if (result == C.RESULT_BUFFER_READ && !buffer.isEndOfStream()) {
+        buffer.timeUs -= startUs;
+      }
       return result;
       return result;
     }
     }
 
 
@@ -326,7 +321,7 @@ public final class ClippingMediaPeriod implements MediaPeriod, MediaPeriod.Callb
       if (isPendingInitialDiscontinuity()) {
       if (isPendingInitialDiscontinuity()) {
         return C.RESULT_NOTHING_READ;
         return C.RESULT_NOTHING_READ;
       }
       }
-      return childStream.skipData(positionUs);
+      return childStream.skipData(startUs + positionUs);
     }
     }
 
 
   }
   }

library/core/src/test/java/com/google/android/exoplayer2/source/ClippingMediaSourceTest.java

@@ -99,7 +99,7 @@ public final class ClippingMediaSourceTest {
     assertThat(clippedTimeline.getWindow(0, window).getDurationUs())
     assertThat(clippedTimeline.getWindow(0, window).getDurationUs())
         .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US);
         .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US);
     assertThat(clippedTimeline.getPeriod(0, period).getDurationUs())
     assertThat(clippedTimeline.getPeriod(0, period).getDurationUs())
-        .isEqualTo(TEST_PERIOD_DURATION_US);
+        .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US);
   }
   }
 
 
   @Test
   @Test
@@ -128,7 +128,7 @@ public final class ClippingMediaSourceTest {
     assertThat(clippedTimeline.getWindow(0, window).getDurationUs())
     assertThat(clippedTimeline.getWindow(0, window).getDurationUs())
         .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US * 3);
         .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US * 3);
     assertThat(clippedTimeline.getPeriod(0, period).getDurationUs())
     assertThat(clippedTimeline.getPeriod(0, period).getDurationUs())
-        .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US * 2);
+        .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US * 3);
   }
   }
 
 
   @Test
   @Test
@@ -171,7 +171,7 @@ public final class ClippingMediaSourceTest {
     assertThat(clippedTimeline.getWindow(0, window).getDurationUs())
     assertThat(clippedTimeline.getWindow(0, window).getDurationUs())
         .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US * 3);
         .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US * 3);
     assertThat(clippedTimeline.getPeriod(0, period).getDurationUs())
     assertThat(clippedTimeline.getPeriod(0, period).getDurationUs())
-        .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US * 2);
+        .isEqualTo(TEST_PERIOD_DURATION_US - TEST_CLIP_AMOUNT_US * 3);
   }
   }
 
 
   @Test
   @Test