From 072720270d5090bf159fc3760c44c12e36995edd Mon Sep 17 00:00:00 2001 From: bachinger Date: Wed, 11 Mar 2020 23:12:01 +0000 Subject: [PATCH] remove PlaybackParameter dependency from MediaClock After this change MediaClocks and ExoPlayerImplInternal don't depend on the deprecated PlaybackParameter anymore but only know about playbackSpeed. PiperOrigin-RevId: 300428791 --- .../android/exoplayer2/DefaultMediaClock.java | 51 +++--- .../android/exoplayer2/ExoPlayerImpl.java | 2 +- .../exoplayer2/ExoPlayerImplInternal.java | 62 ++++---- .../audio/MediaCodecAudioRenderer.java | 9 +- .../audio/SimpleDecoderAudioRenderer.java | 9 +- .../android/exoplayer2/util/MediaClock.java | 17 +- .../exoplayer2/util/StandaloneMediaClock.java | 26 ++-- .../exoplayer2/DefaultMediaClockTest.java | 145 +++++++++--------- .../android/exoplayer2/ExoPlayerTest.java | 12 +- 9 files changed, 159 insertions(+), 174 deletions(-) diff --git a/library/core/src/main/java/com/google/android/exoplayer2/DefaultMediaClock.java b/library/core/src/main/java/com/google/android/exoplayer2/DefaultMediaClock.java index 1971a4cefc..5700964967 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/DefaultMediaClock.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/DefaultMediaClock.java @@ -26,22 +26,20 @@ import com.google.android.exoplayer2.util.StandaloneMediaClock; */ /* package */ final class DefaultMediaClock implements MediaClock { - /** - * Listener interface to be notified of changes to the active playback parameters. - */ - public interface PlaybackParameterListener { + /** Listener interface to be notified of changes to the active playback speed. */ + public interface PlaybackSpeedListener { /** - * Called when the active playback parameters changed. Will not be called for {@link - * #setPlaybackParameters(PlaybackParameters)}. + * Called when the active playback speed changed. Will not be called for {@link + * #setPlaybackSpeed(float)}. * - * @param newPlaybackParameters The newly active {@link PlaybackParameters}. + * @param newPlaybackSpeed The newly active playback speed. */ - void onPlaybackParametersChanged(PlaybackParameters newPlaybackParameters); + void onPlaybackSpeedChanged(float newPlaybackSpeed); } private final StandaloneMediaClock standaloneClock; - private final PlaybackParameterListener listener; + private final PlaybackSpeedListener listener; @Nullable private Renderer rendererClockSource; @Nullable private MediaClock rendererClock; @@ -49,14 +47,13 @@ import com.google.android.exoplayer2.util.StandaloneMediaClock; private boolean standaloneClockIsStarted; /** - * Creates a new instance with listener for playback parameter changes and a {@link Clock} to use - * for the standalone clock implementation. + * Creates a new instance with listener for playback speed changes and a {@link Clock} to use for + * the standalone clock implementation. * - * @param listener A {@link PlaybackParameterListener} to listen for playback parameter - * changes. + * @param listener A {@link PlaybackSpeedListener} to listen for playback speed changes. * @param clock A {@link Clock}. */ - public DefaultMediaClock(PlaybackParameterListener listener, Clock clock) { + public DefaultMediaClock(PlaybackSpeedListener listener, Clock clock) { this.listener = listener; this.standaloneClock = new StandaloneMediaClock(clock); isUsingStandaloneClock = true; @@ -96,7 +93,7 @@ import com.google.android.exoplayer2.util.StandaloneMediaClock; * clock is already provided. */ public void onRendererEnabled(Renderer renderer) throws ExoPlaybackException { - MediaClock rendererMediaClock = renderer.getMediaClock(); + @Nullable MediaClock rendererMediaClock = renderer.getMediaClock(); if (rendererMediaClock != null && rendererMediaClock != rendererClock) { if (rendererClock != null) { throw ExoPlaybackException.createForUnexpected( @@ -104,7 +101,7 @@ import com.google.android.exoplayer2.util.StandaloneMediaClock; } this.rendererClock = rendererMediaClock; this.rendererClockSource = renderer; - rendererClock.setPlaybackParameters(standaloneClock.getPlaybackParameters()); + rendererClock.setPlaybackSpeed(standaloneClock.getPlaybackSpeed()); } } @@ -140,19 +137,19 @@ import com.google.android.exoplayer2.util.StandaloneMediaClock; } @Override - public void setPlaybackParameters(PlaybackParameters playbackParameters) { + public void setPlaybackSpeed(float playbackSpeed) { if (rendererClock != null) { - rendererClock.setPlaybackParameters(playbackParameters); - playbackParameters = rendererClock.getPlaybackParameters(); + rendererClock.setPlaybackSpeed(playbackSpeed); + playbackSpeed = rendererClock.getPlaybackSpeed(); } - standaloneClock.setPlaybackParameters(playbackParameters); + standaloneClock.setPlaybackSpeed(playbackSpeed); } @Override - public PlaybackParameters getPlaybackParameters() { + public float getPlaybackSpeed() { return rendererClock != null - ? rendererClock.getPlaybackParameters() - : standaloneClock.getPlaybackParameters(); + ? rendererClock.getPlaybackSpeed() + : standaloneClock.getPlaybackSpeed(); } private void syncClocks(boolean isReadingAhead) { @@ -177,10 +174,10 @@ import com.google.android.exoplayer2.util.StandaloneMediaClock; } // Continuously sync stand-alone clock to renderer clock so that it can take over if needed. standaloneClock.resetPosition(rendererClockPositionUs); - PlaybackParameters playbackParameters = rendererClock.getPlaybackParameters(); - if (!playbackParameters.equals(standaloneClock.getPlaybackParameters())) { - standaloneClock.setPlaybackParameters(playbackParameters); - listener.onPlaybackParametersChanged(playbackParameters); + float playbackSpeed = rendererClock.getPlaybackSpeed(); + if (playbackSpeed != standaloneClock.getPlaybackSpeed()) { + standaloneClock.setPlaybackSpeed(playbackSpeed); + listener.onPlaybackSpeedChanged(playbackSpeed); } } diff --git a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java index 7b56e99111..f19521f38b 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java @@ -562,7 +562,7 @@ import java.util.concurrent.TimeoutException; pendingSetPlaybackSpeedAcks++; this.playbackSpeed = playbackSpeed; PlaybackParameters playbackParameters = new PlaybackParameters(playbackSpeed); - internalPlayer.setPlaybackParameters(playbackParameters); + internalPlayer.setPlaybackSpeed(playbackSpeed); notifyListeners( listener -> { listener.onPlaybackParametersChanged(playbackParameters); diff --git a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java index dd28459cd3..2e0dfddd03 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java @@ -24,7 +24,7 @@ import android.os.SystemClock; import android.util.Pair; import androidx.annotation.CheckResult; import androidx.annotation.Nullable; -import com.google.android.exoplayer2.DefaultMediaClock.PlaybackParameterListener; +import com.google.android.exoplayer2.DefaultMediaClock.PlaybackSpeedListener; import com.google.android.exoplayer2.Player.DiscontinuityReason; import com.google.android.exoplayer2.Player.PlayWhenReadyChangeReason; import com.google.android.exoplayer2.Player.PlaybackSuppressionReason; @@ -57,7 +57,7 @@ import java.util.concurrent.atomic.AtomicBoolean; MediaPeriod.Callback, TrackSelector.InvalidationListener, Playlist.PlaylistInfoRefreshListener, - PlaybackParameterListener, + PlaybackSpeedListener, PlayerMessage.Sender { private static final String TAG = "ExoPlayerImplInternal"; @@ -71,7 +71,7 @@ import java.util.concurrent.atomic.AtomicBoolean; private static final int MSG_SET_PLAY_WHEN_READY = 1; private static final int MSG_DO_SOME_WORK = 2; private static final int MSG_SEEK_TO = 3; - private static final int MSG_SET_PLAYBACK_PARAMETERS = 4; + private static final int MSG_SET_PLAYBACK_SPEED = 4; private static final int MSG_SET_SEEK_PARAMETERS = 5; private static final int MSG_STOP = 6; private static final int MSG_RELEASE = 7; @@ -83,7 +83,7 @@ import java.util.concurrent.atomic.AtomicBoolean; private static final int MSG_SET_FOREGROUND_MODE = 13; private static final int MSG_SEND_MESSAGE = 14; private static final int MSG_SEND_MESSAGE_TO_TARGET_THREAD = 15; - private static final int MSG_PLAYBACK_PARAMETERS_CHANGED_INTERNAL = 16; + private static final int MSG_PLAYBACK_SPEED_CHANGED_INTERNAL = 16; private static final int MSG_SET_MEDIA_SOURCES = 17; private static final int MSG_ADD_MEDIA_SOURCES = 18; private static final int MSG_MOVE_MEDIA_SOURCES = 19; @@ -224,8 +224,8 @@ import java.util.concurrent.atomic.AtomicBoolean; .sendToTarget(); } - public void setPlaybackParameters(PlaybackParameters playbackParameters) { - handler.obtainMessage(MSG_SET_PLAYBACK_PARAMETERS, playbackParameters).sendToTarget(); + public void setPlaybackSpeed(float playbackSpeed) { + handler.obtainMessage(MSG_SET_PLAYBACK_SPEED, playbackSpeed).sendToTarget(); } public void setSeekParameters(SeekParameters seekParameters) { @@ -365,11 +365,11 @@ import java.util.concurrent.atomic.AtomicBoolean; handler.sendEmptyMessage(MSG_TRACK_SELECTION_INVALIDATED); } - // DefaultMediaClock.PlaybackParameterListener implementation. + // DefaultMediaClock.PlaybackSpeedListener implementation. @Override - public void onPlaybackParametersChanged(PlaybackParameters playbackParameters) { - sendPlaybackParametersChangedInternal(playbackParameters, /* acknowledgeCommand= */ false); + public void onPlaybackSpeedChanged(float playbackSpeed) { + sendPlaybackSpeedChangedInternal(playbackSpeed, /* acknowledgeCommand= */ false); } // Handler.Callback implementation. @@ -401,8 +401,8 @@ import java.util.concurrent.atomic.AtomicBoolean; case MSG_SEEK_TO: seekToInternal((SeekPosition) msg.obj); break; - case MSG_SET_PLAYBACK_PARAMETERS: - setPlaybackParametersInternal((PlaybackParameters) msg.obj); + case MSG_SET_PLAYBACK_SPEED: + setPlaybackSpeedInternal((Float) msg.obj); break; case MSG_SET_SEEK_PARAMETERS: setSeekParametersInternal((SeekParameters) msg.obj); @@ -426,9 +426,8 @@ import java.util.concurrent.atomic.AtomicBoolean; case MSG_TRACK_SELECTION_INVALIDATED: reselectTracksInternal(); break; - case MSG_PLAYBACK_PARAMETERS_CHANGED_INTERNAL: - handlePlaybackParameters( - (PlaybackParameters) msg.obj, /* acknowledgeCommand= */ msg.arg1 != 0); + case MSG_PLAYBACK_SPEED_CHANGED_INTERNAL: + handlePlaybackSpeed((Float) msg.obj, /* acknowledgeCommand= */ msg.arg1 != 0); break; case MSG_SEND_MESSAGE: sendMessageInternal((PlayerMessage) msg.obj); @@ -1089,10 +1088,9 @@ import java.util.concurrent.atomic.AtomicBoolean; notifyTrackSelectionDiscontinuity(); } - private void setPlaybackParametersInternal(PlaybackParameters playbackParameters) { - mediaClock.setPlaybackParameters(playbackParameters); - sendPlaybackParametersChangedInternal( - mediaClock.getPlaybackParameters(), /* acknowledgeCommand= */ true); + private void setPlaybackSpeedInternal(float playbackSpeed) { + mediaClock.setPlaybackSpeed(playbackSpeed); + sendPlaybackSpeedChangedInternal(mediaClock.getPlaybackSpeed(), /* acknowledgeCommand= */ true); } private void setSeekParametersInternal(SeekParameters seekParameters) { @@ -1419,7 +1417,7 @@ import java.util.concurrent.atomic.AtomicBoolean; } private void reselectTracksInternal() throws ExoPlaybackException { - float playbackSpeed = mediaClock.getPlaybackParameters().speed; + float playbackSpeed = mediaClock.getPlaybackSpeed(); // Reselect tracks on each period in turn, until the selection changes. MediaPeriodHolder periodHolder = queue.getPlayingPeriod(); MediaPeriodHolder readingPeriodHolder = queue.getReadingPeriod(); @@ -1542,7 +1540,7 @@ import java.util.concurrent.atomic.AtomicBoolean; boolean bufferedToEnd = loadingHolder.isFullyBuffered() && loadingHolder.info.isFinal; return bufferedToEnd || loadControl.shouldStartPlayback( - getTotalBufferedDurationUs(), mediaClock.getPlaybackParameters().speed, rebuffering); + getTotalBufferedDurationUs(), mediaClock.getPlaybackSpeed(), rebuffering); } private boolean isTimelineReady() { @@ -1871,8 +1869,7 @@ import java.util.concurrent.atomic.AtomicBoolean; return; } MediaPeriodHolder loadingPeriodHolder = queue.getLoadingPeriod(); - loadingPeriodHolder.handlePrepared( - mediaClock.getPlaybackParameters().speed, playbackInfo.timeline); + loadingPeriodHolder.handlePrepared(mediaClock.getPlaybackSpeed(), playbackInfo.timeline); updateLoadControlTrackSelection( loadingPeriodHolder.getTrackGroups(), loadingPeriodHolder.getTrackSelectorResult()); if (loadingPeriodHolder == queue.getPlayingPeriod()) { @@ -1897,17 +1894,15 @@ import java.util.concurrent.atomic.AtomicBoolean; maybeContinueLoading(); } - private void handlePlaybackParameters( - PlaybackParameters playbackParameters, boolean acknowledgeCommand) + private void handlePlaybackSpeed(float playbackSpeed, boolean acknowledgeCommand) throws ExoPlaybackException { eventHandler - .obtainMessage( - MSG_PLAYBACK_SPEED_CHANGED, acknowledgeCommand ? 1 : 0, 0, playbackParameters.speed) + .obtainMessage(MSG_PLAYBACK_SPEED_CHANGED, acknowledgeCommand ? 1 : 0, 0, playbackSpeed) .sendToTarget(); - updateTrackSelectionPlaybackSpeed(playbackParameters.speed); + updateTrackSelectionPlaybackSpeed(playbackSpeed); for (Renderer renderer : renderers) { if (renderer != null) { - renderer.setOperatingRate(playbackParameters.speed); + renderer.setOperatingRate(playbackSpeed); } } } @@ -1933,8 +1928,7 @@ import java.util.concurrent.atomic.AtomicBoolean; // where playback gets stuck. return true; } - float playbackSpeed = mediaClock.getPlaybackParameters().speed; - return loadControl.shouldContinueLoading(bufferedDurationUs, playbackSpeed); + return loadControl.shouldContinueLoading(bufferedDurationUs, mediaClock.getPlaybackSpeed()); } private boolean isLoadingPossible() { @@ -2123,14 +2117,10 @@ import java.util.concurrent.atomic.AtomicBoolean; loadControl.onTracksSelected(renderers, trackGroups, trackSelectorResult.selections); } - private void sendPlaybackParametersChangedInternal( - PlaybackParameters playbackParameters, boolean acknowledgeCommand) { + private void sendPlaybackSpeedChangedInternal(float playbackSpeed, boolean acknowledgeCommand) { handler .obtainMessage( - MSG_PLAYBACK_PARAMETERS_CHANGED_INTERNAL, - acknowledgeCommand ? 1 : 0, - 0, - playbackParameters) + MSG_PLAYBACK_SPEED_CHANGED_INTERNAL, acknowledgeCommand ? 1 : 0, 0, playbackSpeed) .sendToTarget(); } diff --git a/library/core/src/main/java/com/google/android/exoplayer2/audio/MediaCodecAudioRenderer.java b/library/core/src/main/java/com/google/android/exoplayer2/audio/MediaCodecAudioRenderer.java index 883f033576..432844720f 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/audio/MediaCodecAudioRenderer.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/audio/MediaCodecAudioRenderer.java @@ -28,7 +28,6 @@ import com.google.android.exoplayer2.ExoPlaybackException; import com.google.android.exoplayer2.ExoPlayer; import com.google.android.exoplayer2.Format; import com.google.android.exoplayer2.FormatHolder; -import com.google.android.exoplayer2.PlaybackParameters; import com.google.android.exoplayer2.PlayerMessage.Target; import com.google.android.exoplayer2.RendererCapabilities; import com.google.android.exoplayer2.audio.AudioRendererEventListener.EventDispatcher; @@ -567,13 +566,13 @@ public class MediaCodecAudioRenderer extends MediaCodecRenderer implements Media } @Override - public void setPlaybackParameters(PlaybackParameters playbackParameters) { - audioSink.setPlaybackParameters(playbackParameters); + public void setPlaybackSpeed(float playbackSpeed) { + audioSink.setPlaybackSpeed(playbackSpeed); } @Override - public PlaybackParameters getPlaybackParameters() { - return audioSink.getPlaybackParameters(); + public float getPlaybackSpeed() { + return audioSink.getPlaybackSpeed(); } @Override diff --git a/library/core/src/main/java/com/google/android/exoplayer2/audio/SimpleDecoderAudioRenderer.java b/library/core/src/main/java/com/google/android/exoplayer2/audio/SimpleDecoderAudioRenderer.java index 2ef1fb6873..14fc8fc8dc 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/audio/SimpleDecoderAudioRenderer.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/audio/SimpleDecoderAudioRenderer.java @@ -26,7 +26,6 @@ import com.google.android.exoplayer2.ExoPlaybackException; import com.google.android.exoplayer2.ExoPlayer; import com.google.android.exoplayer2.Format; import com.google.android.exoplayer2.FormatHolder; -import com.google.android.exoplayer2.PlaybackParameters; import com.google.android.exoplayer2.PlayerMessage.Target; import com.google.android.exoplayer2.RendererCapabilities; import com.google.android.exoplayer2.audio.AudioRendererEventListener.EventDispatcher; @@ -487,13 +486,13 @@ public abstract class SimpleDecoderAudioRenderer extends BaseRenderer implements } @Override - public void setPlaybackParameters(PlaybackParameters playbackParameters) { - audioSink.setPlaybackParameters(playbackParameters); + public void setPlaybackSpeed(float playbackSpeed) { + audioSink.setPlaybackSpeed(playbackSpeed); } @Override - public PlaybackParameters getPlaybackParameters() { - return audioSink.getPlaybackParameters(); + public float getPlaybackSpeed() { + return audioSink.getPlaybackSpeed(); } @Override diff --git a/library/core/src/main/java/com/google/android/exoplayer2/util/MediaClock.java b/library/core/src/main/java/com/google/android/exoplayer2/util/MediaClock.java index e9f08a35c9..44c3c5e7fa 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/util/MediaClock.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/util/MediaClock.java @@ -15,8 +15,6 @@ */ package com.google.android.exoplayer2.util; -import com.google.android.exoplayer2.PlaybackParameters; - /** * Tracks the progression of media time. */ @@ -28,16 +26,13 @@ public interface MediaClock { long getPositionUs(); /** - * Attempts to set the playback parameters. The media clock may override these parameters if they - * are not supported. + * Attempts to set the playback speed. The media clock may override the speed if changing the + * speed is not supported. * - * @param playbackParameters The playback parameters to attempt to set. + * @param playbackSpeed The playback speed to attempt to set. */ - void setPlaybackParameters(PlaybackParameters playbackParameters); - - /** - * Returns the active playback parameters. - */ - PlaybackParameters getPlaybackParameters(); + void setPlaybackSpeed(float playbackSpeed); + /** Returns the active playback speed. */ + float getPlaybackSpeed(); } diff --git a/library/core/src/main/java/com/google/android/exoplayer2/util/StandaloneMediaClock.java b/library/core/src/main/java/com/google/android/exoplayer2/util/StandaloneMediaClock.java index e5f9aa645f..e1df77a200 100644 --- a/library/core/src/main/java/com/google/android/exoplayer2/util/StandaloneMediaClock.java +++ b/library/core/src/main/java/com/google/android/exoplayer2/util/StandaloneMediaClock.java @@ -16,7 +16,7 @@ package com.google.android.exoplayer2.util; import com.google.android.exoplayer2.C; -import com.google.android.exoplayer2.PlaybackParameters; +import com.google.android.exoplayer2.Player; /** * A {@link MediaClock} whose position advances with real time based on the playback parameters when @@ -29,7 +29,8 @@ public final class StandaloneMediaClock implements MediaClock { private boolean started; private long baseUs; private long baseElapsedMs; - private PlaybackParameters playbackParameters; + private float playbackSpeed; + private int scaledUsPerMs; /** * Creates a new standalone media clock using the given {@link Clock} implementation. @@ -38,7 +39,8 @@ public final class StandaloneMediaClock implements MediaClock { */ public StandaloneMediaClock(Clock clock) { this.clock = clock; - this.playbackParameters = PlaybackParameters.DEFAULT; + playbackSpeed = Player.DEFAULT_PLAYBACK_SPEED; + scaledUsPerMs = getScaledUsPerMs(playbackSpeed); } /** @@ -78,27 +80,33 @@ public final class StandaloneMediaClock implements MediaClock { long positionUs = baseUs; if (started) { long elapsedSinceBaseMs = clock.elapsedRealtime() - baseElapsedMs; - if (playbackParameters.speed == 1f) { + if (playbackSpeed == 1f) { positionUs += C.msToUs(elapsedSinceBaseMs); } else { - positionUs += playbackParameters.getMediaTimeUsForPlayoutTimeMs(elapsedSinceBaseMs); + // Add the media time in microseconds that will elapse in elapsedSinceBaseMs milliseconds of + // wallclock time + positionUs += elapsedSinceBaseMs * scaledUsPerMs; } } return positionUs; } @Override - public void setPlaybackParameters(PlaybackParameters playbackParameters) { + public void setPlaybackSpeed(float playbackSpeed) { // Store the current position as the new base, in case the playback speed has changed. if (started) { resetPosition(getPositionUs()); } - this.playbackParameters = playbackParameters; + this.playbackSpeed = playbackSpeed; + scaledUsPerMs = getScaledUsPerMs(playbackSpeed); } @Override - public PlaybackParameters getPlaybackParameters() { - return playbackParameters; + public float getPlaybackSpeed() { + return playbackSpeed; } + private static int getScaledUsPerMs(float playbackSpeed) { + return Math.round(playbackSpeed * 1000f); + } } diff --git a/library/core/src/test/java/com/google/android/exoplayer2/DefaultMediaClockTest.java b/library/core/src/test/java/com/google/android/exoplayer2/DefaultMediaClockTest.java index b6e3d7a648..bb9656be27 100644 --- a/library/core/src/test/java/com/google/android/exoplayer2/DefaultMediaClockTest.java +++ b/library/core/src/test/java/com/google/android/exoplayer2/DefaultMediaClockTest.java @@ -22,7 +22,7 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.MockitoAnnotations.initMocks; import androidx.test.ext.junit.runners.AndroidJUnit4; -import com.google.android.exoplayer2.DefaultMediaClock.PlaybackParameterListener; +import com.google.android.exoplayer2.DefaultMediaClock.PlaybackSpeedListener; import com.google.android.exoplayer2.testutil.FakeClock; import com.google.android.exoplayer2.testutil.FakeMediaClockRenderer; import org.junit.Before; @@ -36,10 +36,9 @@ public class DefaultMediaClockTest { private static final long TEST_POSITION_US = 123456789012345678L; private static final long SLEEP_TIME_MS = 1_000; - private static final PlaybackParameters TEST_PLAYBACK_PARAMETERS = - new PlaybackParameters(/* speed= */ 2f); + private static final float TEST_PLAYBACK_SPEED = 2f; - @Mock private PlaybackParameterListener listener; + @Mock private PlaybackSpeedListener listener; private FakeClock fakeClock; private DefaultMediaClock mediaClock; @@ -110,119 +109,117 @@ public class DefaultMediaClockTest { } @Test - public void standaloneGetPlaybackParameters_initializedWithDefaultPlaybackParameters() { - assertThat(mediaClock.getPlaybackParameters()).isEqualTo(PlaybackParameters.DEFAULT); + public void standaloneGetPlaybackSpeed_initializedWithDefaultPlaybackSpeed() { + assertThat(mediaClock.getPlaybackSpeed()).isEqualTo(Player.DEFAULT_PLAYBACK_SPEED); } @Test - public void standaloneSetPlaybackParameters_getPlaybackParametersShouldReturnSameValue() { - mediaClock.setPlaybackParameters(TEST_PLAYBACK_PARAMETERS); - assertThat(mediaClock.getPlaybackParameters()).isEqualTo(TEST_PLAYBACK_PARAMETERS); + public void standaloneSetPlaybackSpeed_getPlaybackSpeedShouldReturnSameValue() { + mediaClock.setPlaybackSpeed(TEST_PLAYBACK_SPEED); + assertThat(mediaClock.getPlaybackSpeed()).isEqualTo(TEST_PLAYBACK_SPEED); } @Test - public void standaloneSetPlaybackParameters_shouldNotTriggerCallback() { - mediaClock.setPlaybackParameters(TEST_PLAYBACK_PARAMETERS); + public void standaloneSetPlaybackSpeed_shouldNotTriggerCallback() { + mediaClock.setPlaybackSpeed(TEST_PLAYBACK_SPEED); verifyNoMoreInteractions(listener); } @Test - public void standaloneSetPlaybackParameters_shouldApplyNewPlaybackSpeed() { - mediaClock.setPlaybackParameters(TEST_PLAYBACK_PARAMETERS); + public void standaloneSetPlaybackSpeed_shouldApplyNewPlaybackSpeed() { + mediaClock.setPlaybackSpeed(TEST_PLAYBACK_SPEED); mediaClock.start(); - // Asserts that clock is running with speed declared in getPlaybackParameters(). + // Asserts that clock is running with speed declared in getPlaybackSpeed(). assertClockIsRunning(/* isReadingAhead= */ false); } @Test - public void standaloneSetOtherPlaybackParameters_getPlaybackParametersShouldReturnSameValue() { - mediaClock.setPlaybackParameters(TEST_PLAYBACK_PARAMETERS); - mediaClock.setPlaybackParameters(PlaybackParameters.DEFAULT); - assertThat(mediaClock.getPlaybackParameters()).isEqualTo(PlaybackParameters.DEFAULT); + public void standaloneSetOtherPlaybackSpeed_getPlaybackSpeedShouldReturnSameValue() { + mediaClock.setPlaybackSpeed(TEST_PLAYBACK_SPEED); + mediaClock.setPlaybackSpeed(Player.DEFAULT_PLAYBACK_SPEED); + assertThat(mediaClock.getPlaybackSpeed()).isEqualTo(Player.DEFAULT_PLAYBACK_SPEED); } @Test - public void enableRendererMediaClock_shouldOverwriteRendererPlaybackParametersIfPossible() + public void enableRendererMediaClock_shouldOverwriteRendererPlaybackSpeedIfPossible() throws ExoPlaybackException { FakeMediaClockRenderer mediaClockRenderer = - new MediaClockRenderer(TEST_PLAYBACK_PARAMETERS, /* playbackParametersAreMutable= */ true); + new MediaClockRenderer(TEST_PLAYBACK_SPEED, /* playbackSpeedIsMutable= */ true); mediaClock.onRendererEnabled(mediaClockRenderer); - assertThat(mediaClock.getPlaybackParameters()).isEqualTo(PlaybackParameters.DEFAULT); + assertThat(mediaClock.getPlaybackSpeed()).isEqualTo(Player.DEFAULT_PLAYBACK_SPEED); verifyNoMoreInteractions(listener); } @Test - public void enableRendererMediaClockWithFixedParameters_usesRendererPlaybackParameters() + public void enableRendererMediaClockWithFixedPlaybackSpeed_usesRendererPlaybackSpeed() throws ExoPlaybackException { FakeMediaClockRenderer mediaClockRenderer = - new MediaClockRenderer(TEST_PLAYBACK_PARAMETERS, /* playbackParametersAreMutable= */ false); + new MediaClockRenderer(TEST_PLAYBACK_SPEED, /* playbackSpeedIsMutable= */ false); mediaClock.onRendererEnabled(mediaClockRenderer); - assertThat(mediaClock.getPlaybackParameters()).isEqualTo(TEST_PLAYBACK_PARAMETERS); + assertThat(mediaClock.getPlaybackSpeed()).isEqualTo(TEST_PLAYBACK_SPEED); } @Test - public void enableRendererMediaClockWithFixedParameters_shouldTriggerCallback() + public void enableRendererMediaClockWithFixedPlaybackSpeed_shouldTriggerCallback() throws ExoPlaybackException { FakeMediaClockRenderer mediaClockRenderer = - new MediaClockRenderer(TEST_PLAYBACK_PARAMETERS, /* playbackParametersAreMutable= */ false); + new MediaClockRenderer(TEST_PLAYBACK_SPEED, /* playbackSpeedIsMutable= */ false); mediaClock.onRendererEnabled(mediaClockRenderer); mediaClock.syncAndGetPositionUs(/* isReadingAhead= */ false); - verify(listener).onPlaybackParametersChanged(TEST_PLAYBACK_PARAMETERS); + verify(listener).onPlaybackSpeedChanged(TEST_PLAYBACK_SPEED); } @Test - public void enableRendererMediaClockWithFixedButSamePlaybackParameters_shouldNotTriggerCallback() + public void enableRendererMediaClockWithFixedButSamePlaybackSpeed_shouldNotTriggerCallback() throws ExoPlaybackException { - FakeMediaClockRenderer mediaClockRenderer = new MediaClockRenderer(PlaybackParameters.DEFAULT, - /* playbackParametersAreMutable= */ false); + FakeMediaClockRenderer mediaClockRenderer = + new MediaClockRenderer(Player.DEFAULT_PLAYBACK_SPEED, /* playbackSpeedIsMutable= */ false); mediaClock.onRendererEnabled(mediaClockRenderer); mediaClock.syncAndGetPositionUs(/* isReadingAhead= */ false); verifyNoMoreInteractions(listener); } @Test - public void disableRendererMediaClock_shouldKeepPlaybackParameters() - throws ExoPlaybackException { + public void disableRendererMediaClock_shouldKeepPlaybackSpeed() throws ExoPlaybackException { FakeMediaClockRenderer mediaClockRenderer = - new MediaClockRenderer(TEST_PLAYBACK_PARAMETERS, /* playbackParametersAreMutable= */ false); + new MediaClockRenderer(TEST_PLAYBACK_SPEED, /* playbackSpeedIsMutable= */ false); mediaClock.onRendererEnabled(mediaClockRenderer); mediaClock.syncAndGetPositionUs(/* isReadingAhead= */ false); mediaClock.onRendererDisabled(mediaClockRenderer); mediaClock.syncAndGetPositionUs(/* isReadingAhead= */ false); - assertThat(mediaClock.getPlaybackParameters()).isEqualTo(TEST_PLAYBACK_PARAMETERS); + assertThat(mediaClock.getPlaybackSpeed()).isEqualTo(TEST_PLAYBACK_SPEED); } @Test - public void rendererClockSetPlaybackParameters_getPlaybackParametersShouldReturnSameValue() + public void rendererClockSetPlaybackSpeed_getPlaybackSpeedShouldReturnSameValue() throws ExoPlaybackException { - FakeMediaClockRenderer mediaClockRenderer = new MediaClockRenderer(PlaybackParameters.DEFAULT, - /* playbackParametersAreMutable= */ true); + FakeMediaClockRenderer mediaClockRenderer = + new MediaClockRenderer(Player.DEFAULT_PLAYBACK_SPEED, /* playbackSpeedIsMutable= */ true); mediaClock.onRendererEnabled(mediaClockRenderer); mediaClock.syncAndGetPositionUs(/* isReadingAhead= */ false); - mediaClock.setPlaybackParameters(TEST_PLAYBACK_PARAMETERS); - assertThat(mediaClock.getPlaybackParameters()).isEqualTo(TEST_PLAYBACK_PARAMETERS); + mediaClock.setPlaybackSpeed(TEST_PLAYBACK_SPEED); + assertThat(mediaClock.getPlaybackSpeed()).isEqualTo(TEST_PLAYBACK_SPEED); } @Test - public void rendererClockSetPlaybackParameters_shouldNotTriggerCallback() - throws ExoPlaybackException { - FakeMediaClockRenderer mediaClockRenderer = new MediaClockRenderer(PlaybackParameters.DEFAULT, - /* playbackParametersAreMutable= */ true); + public void rendererClockSetPlaybackSpeed_shouldNotTriggerCallback() throws ExoPlaybackException { + FakeMediaClockRenderer mediaClockRenderer = + new MediaClockRenderer(Player.DEFAULT_PLAYBACK_SPEED, /* playbackSpeedIsMutable= */ true); mediaClock.onRendererEnabled(mediaClockRenderer); mediaClock.syncAndGetPositionUs(/* isReadingAhead= */ false); - mediaClock.setPlaybackParameters(TEST_PLAYBACK_PARAMETERS); + mediaClock.setPlaybackSpeed(TEST_PLAYBACK_SPEED); verifyNoMoreInteractions(listener); } @Test - public void rendererClockSetPlaybackParametersOverwrite_getParametersShouldReturnSameValue() + public void rendererClockSetPlaybackSpeedOverwrite_getPlaybackSpeedShouldReturnSameValue() throws ExoPlaybackException { - FakeMediaClockRenderer mediaClockRenderer = new MediaClockRenderer(PlaybackParameters.DEFAULT, - /* playbackParametersAreMutable= */ false); + FakeMediaClockRenderer mediaClockRenderer = + new MediaClockRenderer(Player.DEFAULT_PLAYBACK_SPEED, /* playbackSpeedIsMutable= */ false); mediaClock.onRendererEnabled(mediaClockRenderer); mediaClock.syncAndGetPositionUs(/* isReadingAhead= */ false); - mediaClock.setPlaybackParameters(TEST_PLAYBACK_PARAMETERS); - assertThat(mediaClock.getPlaybackParameters()).isEqualTo(PlaybackParameters.DEFAULT); + mediaClock.setPlaybackSpeed(TEST_PLAYBACK_SPEED); + assertThat(mediaClock.getPlaybackSpeed()).isEqualTo(Player.DEFAULT_PLAYBACK_SPEED); } @Test @@ -266,16 +263,15 @@ public class DefaultMediaClockTest { } @Test - public void getPositionWithPlaybackParameterChange_shouldTriggerCallback() + public void getPositionWithPlaybackSpeedChange_shouldTriggerCallback() throws ExoPlaybackException { MediaClockRenderer mediaClockRenderer = - new MediaClockRenderer( - PlaybackParameters.DEFAULT, /* playbackParametersAreMutable= */ true); + new MediaClockRenderer(Player.DEFAULT_PLAYBACK_SPEED, /* playbackSpeedIsMutable= */ true); mediaClock.onRendererEnabled(mediaClockRenderer); - // Silently change playback parameters of renderer clock. - mediaClockRenderer.playbackParameters = TEST_PLAYBACK_PARAMETERS; + // Silently change playback speed of renderer clock. + mediaClockRenderer.playbackSpeed = TEST_PLAYBACK_SPEED; mediaClock.syncAndGetPositionUs(/* isReadingAhead= */ false); - verify(listener).onPlaybackParametersChanged(TEST_PLAYBACK_PARAMETERS); + verify(listener).onPlaybackSpeedChanged(TEST_PLAYBACK_SPEED); } @Test @@ -360,10 +356,9 @@ public class DefaultMediaClockTest { private void assertClockIsRunning(boolean isReadingAhead) { long clockStartUs = mediaClock.syncAndGetPositionUs(isReadingAhead); fakeClock.advanceTime(SLEEP_TIME_MS); + int scaledUsPerMs = Math.round(mediaClock.getPlaybackSpeed() * 1000f); assertThat(mediaClock.syncAndGetPositionUs(isReadingAhead)) - .isEqualTo( - clockStartUs - + mediaClock.getPlaybackParameters().getMediaTimeUsForPlayoutTimeMs(SLEEP_TIME_MS)); + .isEqualTo(clockStartUs + (SLEEP_TIME_MS * scaledUsPerMs)); } private void assertClockIsStopped() { @@ -376,34 +371,36 @@ public class DefaultMediaClockTest { @SuppressWarnings("HidingField") private static class MediaClockRenderer extends FakeMediaClockRenderer { - private final boolean playbackParametersAreMutable; + private final boolean playbackSpeedIsMutable; private final boolean isReady; private final boolean isEnded; - public PlaybackParameters playbackParameters; + public float playbackSpeed; public long positionUs; public MediaClockRenderer() throws ExoPlaybackException { - this(PlaybackParameters.DEFAULT, false, true, false, false); + this(Player.DEFAULT_PLAYBACK_SPEED, false, true, false, false); } - public MediaClockRenderer(PlaybackParameters playbackParameters, - boolean playbackParametersAreMutable) + public MediaClockRenderer(float playbackSpeed, boolean playbackSpeedIsMutable) throws ExoPlaybackException { - this(playbackParameters, playbackParametersAreMutable, true, false, false); + this(playbackSpeed, playbackSpeedIsMutable, true, false, false); } public MediaClockRenderer(boolean isReady, boolean isEnded, boolean hasReadStreamToEnd) throws ExoPlaybackException { - this(PlaybackParameters.DEFAULT, false, isReady, isEnded, hasReadStreamToEnd); + this(Player.DEFAULT_PLAYBACK_SPEED, false, isReady, isEnded, hasReadStreamToEnd); } - private MediaClockRenderer(PlaybackParameters playbackParameters, - boolean playbackParametersAreMutable, boolean isReady, boolean isEnded, + private MediaClockRenderer( + float playbackSpeed, + boolean playbackSpeedIsMutable, + boolean isReady, + boolean isEnded, boolean hasReadStreamToEnd) throws ExoPlaybackException { - this.playbackParameters = playbackParameters; - this.playbackParametersAreMutable = playbackParametersAreMutable; + this.playbackSpeed = playbackSpeed; + this.playbackSpeedIsMutable = playbackSpeedIsMutable; this.isReady = isReady; this.isEnded = isEnded; this.positionUs = TEST_POSITION_US; @@ -418,15 +415,15 @@ public class DefaultMediaClockTest { } @Override - public void setPlaybackParameters(PlaybackParameters playbackParameters) { - if (playbackParametersAreMutable) { - this.playbackParameters = playbackParameters; + public void setPlaybackSpeed(float playbackSpeed) { + if (playbackSpeedIsMutable) { + this.playbackSpeed = playbackSpeed; } } @Override - public PlaybackParameters getPlaybackParameters() { - return playbackParameters; + public float getPlaybackSpeed() { + return playbackSpeed; } @Override diff --git a/library/core/src/test/java/com/google/android/exoplayer2/ExoPlayerTest.java b/library/core/src/test/java/com/google/android/exoplayer2/ExoPlayerTest.java index d1da02aa2c..0e7d1a7adc 100644 --- a/library/core/src/test/java/com/google/android/exoplayer2/ExoPlayerTest.java +++ b/library/core/src/test/java/com/google/android/exoplayer2/ExoPlayerTest.java @@ -256,11 +256,11 @@ public final class ExoPlayerTest { } @Override - public void setPlaybackParameters(PlaybackParameters playbackParameters) {} + public void setPlaybackSpeed(float playbackSpeed) {} @Override - public PlaybackParameters getPlaybackParameters() { - return PlaybackParameters.DEFAULT; + public float getPlaybackSpeed() { + return Player.DEFAULT_PLAYBACK_SPEED; } @Override @@ -3217,11 +3217,11 @@ public final class ExoPlayerTest { } @Override - public void setPlaybackParameters(PlaybackParameters playbackParameters) {} + public void setPlaybackSpeed(float playbackSpeed) {} @Override - public PlaybackParameters getPlaybackParameters() { - return PlaybackParameters.DEFAULT; + public float getPlaybackSpeed() { + return Player.DEFAULT_PLAYBACK_SPEED; } }; ActionSchedule actionSchedule =