Finalize V2 ExoPlayer API

There's still some internal to clean up to do, and in particular it remains a TODO to be able to handle seek calls before the timeline is set (for this CL, such calls are dropped). This change does however finalize the API. ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=131171318

Finalize V2 ExoPlayer API
There's still some internal to clean up to do, and in particular it remains a TODO to be able to handle seek calls before the timeline is set (for this CL, such calls are dropped). This change does however finalize the API. ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=131171318
5f1a2c71 · olly · Oliver Woodman · 298464eb · 5f1a2c71 · 5f1a2c71
Commit 5f1a2c71 authored Aug 24, 2016 by olly Committed by Oliver Woodman Aug 31, 2016
Showing with 846 additions and 1008 deletions
demo/src/main/java/com/google/android/exoplayer2/demo/EventLogger.java
demo/src/main/java/com/google/android/exoplayer2/demo/PlayerActivity.java
extensions/flac/src/androidTest/java/com/google/android/exoplayer2/ext/flac/FlacPlaybackTest.java
extensions/opus/src/androidTest/java/com/google/android/exoplayer2/ext/opus/OpusPlaybackTest.java
extensions/vp9/src/androidTest/java/com/google/android/exoplayer2/ext/vp9/VpxPlaybackTest.java
library/src/main/java/com/google/android/exoplayer2/ExoPlayer.java
library/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java
library/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java
library/src/main/java/com/google/android/exoplayer2/MediaTimeline.java
library/src/main/java/com/google/android/exoplayer2/MediaWindow.java
library/src/main/java/com/google/android/exoplayer2/SimpleExoPlayer.java
library/src/main/java/com/google/android/exoplayer2/Timeline.java
library/src/main/java/com/google/android/exoplayer2/source/ConcatenatingMediaSource.java
library/src/main/java/com/google/android/exoplayer2/source/ExtractorMediaPeriod.java
library/src/main/java/com/google/android/exoplayer2/source/ExtractorMediaSource.java
library/src/main/java/com/google/android/exoplayer2/source/MediaSource.java
library/src/main/java/com/google/android/exoplayer2/source/MergingMediaSource.java
library/src/main/java/com/google/android/exoplayer2/source/SinglePeriodMediaTimeline.java
library/src/main/java/com/google/android/exoplayer2/source/SinglePeriodTimeline.java
library/src/main/java/com/google/android/exoplayer2/source/SingleSampleMediaSource.java
--- a/demo/src/main/java/com/google/android/exoplayer2/demo/EventLogger.java
+++ b/demo/src/main/java/com/google/android/exoplayer2/demo/EventLogger.java
@@ -22,8 +22,8 @@ import com.google.android.exoplayer2.C;
 import com.google.android.exoplayer2.ExoPlaybackException;
 import com.google.android.exoplayer2.ExoPlayer;
 import com.google.android.exoplayer2.Format;
-import com.google.android.exoplayer2.MediaTimeline;
 import com.google.android.exoplayer2.RendererCapabilities;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.audio.AudioRendererEventListener;
 import com.google.android.exoplayer2.decoder.DecoderCounters;
 import com.google.android.exoplayer2.drm.StreamingDrmSessionManager;
@@ -57,16 +57,22 @@ import java.util.Locale;
    MappingTrackSelector.EventListener, MetadataRenderer.Output<List<Id3Frame>> {
  private static final String TAG = "EventLogger";
+  private static final int MAX_TIMELINE_ITEM_LINES = 3;
  private static final NumberFormat TIME_FORMAT;
  static {
    TIME_FORMAT = NumberFormat.getInstance(Locale.US);
    TIME_FORMAT.setMinimumFractionDigits(2);
    TIME_FORMAT.setMaximumFractionDigits(2);
+    TIME_FORMAT.setGroupingUsed(false);
  }
+  private final Timeline.Window window;
+  private final Timeline.Period period;
  private final long startTimeMs;
  public EventLogger() {
+    window = new Timeline.Window();
+    period = new Timeline.Period();
    startTimeMs = SystemClock.elapsedRealtime();
  }
@@ -89,13 +95,24 @@ import java.util.Locale;
  }
  @Override
-  public void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+  public void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
    int periodCount = timeline.getPeriodCount();
    int windowCount = timeline.getWindowCount();
-    Log.d(TAG, "sourceInfo[startTime=" + timeline.getAbsoluteStartTime() + ", periodCount="
+    Log.d(TAG, "sourceInfo [periodCount=" + periodCount + ", windowCount=" + windowCount);
-        + periodCount + ", windows: " + windowCount);
+    for (int i = 0; i < Math.min(periodCount, MAX_TIMELINE_ITEM_LINES); i++) {
-    for (int windowIndex = 0; windowIndex < windowCount; windowIndex++) {
+      timeline.getPeriod(i, period);
-      Log.d(TAG, "  " + timeline.getWindow(windowIndex));
+      Log.d(TAG, "  " +  "period [" + getTimeString(period.getDurationMs()) + "]");
+    }
+    if (periodCount > MAX_TIMELINE_ITEM_LINES) {
+      Log.d(TAG, "  ...");
+    }
+    for (int i = 0; i < Math.min(windowCount, MAX_TIMELINE_ITEM_LINES); i++) {
+      timeline.getWindow(i, window);
+      Log.d(TAG, "  " +  "window [" + getTimeString(window.getDurationMs()) + ", "
+          + window.isSeekable + ", " + window.isDynamic + "]");
+    }
+    if (windowCount > MAX_TIMELINE_ITEM_LINES) {
+      Log.d(TAG, "  ...");
    }
    Log.d(TAG, "]");
  }
@@ -333,7 +350,7 @@ import java.util.Locale;
  }
  private static String getTimeString(long timeMs) {
-    return TIME_FORMAT.format((timeMs) / 1000f);
+    return timeMs == C.TIME_UNSET ? "?" : TIME_FORMAT.format((timeMs) / 1000f);
  }
  private static String getStateString(int state) {

--- a/demo/src/main/java/com/google/android/exoplayer2/demo/PlayerActivity.java
+++ b/demo/src/main/java/com/google/android/exoplayer2/demo/PlayerActivity.java
@@ -40,9 +40,8 @@ import com.google.android.exoplayer2.DefaultLoadControl;
 import com.google.android.exoplayer2.ExoPlaybackException;
 import com.google.android.exoplayer2.ExoPlayer;
 import com.google.android.exoplayer2.ExoPlayerFactory;
-import com.google.android.exoplayer2.MediaTimeline;
-import com.google.android.exoplayer2.MediaWindow;
 import com.google.android.exoplayer2.SimpleExoPlayer;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.drm.DrmSessionManager;
 import com.google.android.exoplayer2.drm.HttpMediaDrmCallback;
 import com.google.android.exoplayer2.drm.StreamingDrmSessionManager;
@@ -127,7 +126,7 @@ public class PlayerActivity extends Activity implements OnKeyListener, OnTouchLi
  private boolean playerNeedsSource;
  private boolean shouldRestorePosition;
-  private int playerPeriod;
+  private int playerWindow;
  private long playerPosition;
  // Activity lifecycle
@@ -283,9 +282,9 @@ public class PlayerActivity extends Activity implements OnKeyListener, OnTouchLi
      player.setVideoSurfaceHolder(surfaceView.getHolder());
      if (shouldRestorePosition) {
        if (playerPosition == C.TIME_UNSET) {
-          player.seekToDefaultPositionForPeriod(playerPeriod);
+          player.seekToDefaultPosition(playerWindow);
        } else {
-          player.seekInPeriod(playerPeriod, playerPosition);
+          player.seekTo(playerWindow, playerPosition);
        }
      }
      player.setPlayWhenReady(true);
@@ -376,13 +375,13 @@ public class PlayerActivity extends Activity implements OnKeyListener, OnTouchLi
      debugViewHelper.stop();
      debugViewHelper = null;
      shouldRestorePosition = false;
-      MediaTimeline playerTimeline = player.getCurrentTimeline();
+      Timeline timeline = player.getCurrentTimeline();
-      if (playerTimeline != null) {
+      if (timeline != null) {
-        MediaWindow window = playerTimeline.getWindow(player.getCurrentWindowIndex());
+        playerWindow = player.getCurrentWindowIndex();
+        Timeline.Window window = timeline.getWindow(playerWindow, new Timeline.Window());
        if (!window.isDynamic) {
          shouldRestorePosition = true;
-          playerPeriod = player.getCurrentPeriodIndex();
+          playerPosition = window.isSeekable ? player.getCurrentPosition() : C.TIME_UNSET;
-          playerPosition = window.isSeekable ? player.getCurrentPositionInPeriod() : C.TIME_UNSET;
        }
      }
      player.release();
@@ -417,7 +416,7 @@ public class PlayerActivity extends Activity implements OnKeyListener, OnTouchLi
  }
  @Override
-  public void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+  public void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
    // Do nothing.
  }

--- a/extensions/flac/src/androidTest/java/com/google/android/exoplayer2/ext/flac/FlacPlaybackTest.java
+++ b/extensions/flac/src/androidTest/java/com/google/android/exoplayer2/ext/flac/FlacPlaybackTest.java
@@ -22,8 +22,8 @@ import android.test.InstrumentationTestCase;
 import com.google.android.exoplayer2.ExoPlaybackException;
 import com.google.android.exoplayer2.ExoPlayer;
 import com.google.android.exoplayer2.ExoPlayerFactory;
-import com.google.android.exoplayer2.MediaTimeline;
 import com.google.android.exoplayer2.Renderer;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.extractor.mkv.MatroskaExtractor;
 import com.google.android.exoplayer2.source.ExtractorMediaSource;
 import com.google.android.exoplayer2.trackselection.DefaultTrackSelector;
@@ -96,7 +96,7 @@ public class FlacPlaybackTest extends InstrumentationTestCase {
    }
    @Override
-    public void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+    public void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
      // Do nothing.
    }

--- a/extensions/opus/src/androidTest/java/com/google/android/exoplayer2/ext/opus/OpusPlaybackTest.java
+++ b/extensions/opus/src/androidTest/java/com/google/android/exoplayer2/ext/opus/OpusPlaybackTest.java
@@ -22,8 +22,8 @@ import android.test.InstrumentationTestCase;
 import com.google.android.exoplayer2.ExoPlaybackException;
 import com.google.android.exoplayer2.ExoPlayer;
 import com.google.android.exoplayer2.ExoPlayerFactory;
-import com.google.android.exoplayer2.MediaTimeline;
 import com.google.android.exoplayer2.Renderer;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.extractor.mkv.MatroskaExtractor;
 import com.google.android.exoplayer2.source.ExtractorMediaSource;
 import com.google.android.exoplayer2.trackselection.DefaultTrackSelector;
@@ -96,7 +96,7 @@ public class OpusPlaybackTest extends InstrumentationTestCase {
    }
    @Override
-    public void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+    public void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
      // Do nothing.
    }

--- a/extensions/vp9/src/androidTest/java/com/google/android/exoplayer2/ext/vp9/VpxPlaybackTest.java
+++ b/extensions/vp9/src/androidTest/java/com/google/android/exoplayer2/ext/vp9/VpxPlaybackTest.java
@@ -22,8 +22,8 @@ import android.test.InstrumentationTestCase;
 import com.google.android.exoplayer2.ExoPlaybackException;
 import com.google.android.exoplayer2.ExoPlayer;
 import com.google.android.exoplayer2.ExoPlayerFactory;
-import com.google.android.exoplayer2.MediaTimeline;
 import com.google.android.exoplayer2.Renderer;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.extractor.mkv.MatroskaExtractor;
 import com.google.android.exoplayer2.source.ExtractorMediaSource;
 import com.google.android.exoplayer2.trackselection.DefaultTrackSelector;
@@ -115,7 +115,7 @@ public class VpxPlaybackTest extends InstrumentationTestCase {
    }
    @Override
-    public void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+    public void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
      // Do nothing.
    }

--- a/library/src/main/java/com/google/android/exoplayer2/ExoPlayer.java
+++ b/library/src/main/java/com/google/android/exoplayer2/ExoPlayer.java
@@ -117,10 +117,10 @@ public interface ExoPlayer {
     */
    void onPlayerStateChanged(boolean playWhenReady, int playbackState);
-    // TODO[playlists]: Should source-initiated resets also cause this to be called?
+    // TODO: Should be windowIndex and position in the window.
    /**
-     * Called when the player's position changes due to a discontinuity (seeking or playback
+     * Called when the player's position changes due to a discontinuity (i.e. due to seeking,
-     * transitioning to the next period).
+     * playback transitioning to the next window, or a source induced discontinuity).
     *
     * @param periodIndex The index of the period being played.
     * @param positionMs The playback position in that period, in milliseconds.
@@ -133,7 +133,7 @@ public interface ExoPlayer {
     * @param timeline The source's timeline.
     * @param manifest The loaded manifest.
     */
-    void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest);
+    void onSourceInfoRefreshed(Timeline timeline, Object manifest);
    /**
     * Called when an error occurs. The playback state will transition to {@link #STATE_IDLE}
@@ -249,7 +249,7 @@ public interface ExoPlayer {
   * @param mediaSource The {@link MediaSource} to play.
   * @param resetPosition Whether the playback position should be reset to the source's default
   *     position. If false, playback will start from the position defined by
-   *     {@link #getCurrentPeriodIndex()} and {@link #getCurrentPositionInPeriod()}.
+   *     {@link #getCurrentWindowIndex()} and {@link #getCurrentPosition()}.
   */
  void setMediaSource(MediaSource mediaSource, boolean resetPosition);
@@ -278,35 +278,6 @@ public interface ExoPlayer {
  boolean isLoading();
  /**
-   * Seeks to a position specified in milliseconds in the current period.
-   *
-   * @param positionMs The seek position.
-   */
-  @Deprecated
-  void seekInCurrentPeriod(long positionMs);
-  /**
-   * Seeks to the default position associated with the specified period. The position can depend on
-   * the type of source passed to {@link #setMediaSource(MediaSource)}. For live streams it will
-   * typically be the live edge of the window to which the period belongs. For other streams it will
-   * typically be the start of the period.
-   *
-   * @param periodIndex The index of the period whose associated default position should be seeked
-   *     to.
-   */
-  @Deprecated
-  void seekToDefaultPositionForPeriod(int periodIndex);
-  /**
-   * Seeks to a position specified in milliseconds in the specified period.
-   *
-   * @param periodIndex The index of the period.
-   * @param positionMs The seek position relative to the start of the period.
-   */
-  @Deprecated
-  void seekInPeriod(int periodIndex, long positionMs);
-  /**
   * Seeks to the default position associated with the current window. The position can depend on
   * the type of source passed to {@link #setMediaSource(MediaSource)}. For live streams it will
   * typically be the live edge of the window. For other streams it will typically be the start of
@@ -333,7 +304,7 @@ public interface ExoPlayer {
  void seekTo(long positionMs);
  /**
-   * Seeks to a position specified in milliseconds in the specified seek window.
+   * Seeks to a position specified in milliseconds in the specified window.
   *
   * @param windowIndex The index of the window.
   * @param positionMs The seek position relative to the start of the window.
@@ -376,9 +347,9 @@ public interface ExoPlayer {
  void blockingSendMessages(ExoPlayerMessage... messages);
  /**
-   * Returns the current {@link MediaTimeline}, or {@code null} if there is no timeline.
+   * Returns the current {@link Timeline}, or {@code null} if there is no timeline.
   */
-  MediaTimeline getCurrentTimeline();
+  Timeline getCurrentTimeline();
  /**
   * Returns the current manifest. The type depends on the {@link MediaSource} passed to
@@ -386,46 +357,9 @@ public interface ExoPlayer {
   */
  Object getCurrentManifest();
-  // Period based.
-  /**
-   * Returns the index of the current period.
-   */
-  @Deprecated
-  int getCurrentPeriodIndex();
-  /**
-   * Returns the duration of the current period in milliseconds, or {@link C#TIME_UNSET} if the
-   * duration is not known.
-   */
-  @Deprecated
-  long getCurrentPeriodDuration();
-  /**
-   * Returns the playback position in the current period, in milliseconds.
-   */
-  @Deprecated
-  long getCurrentPositionInPeriod();
-  /**
-   * Returns an estimate of the position in the current period up to which data is buffered, or
-   * {@link C#TIME_UNSET} if no estimate is available.
-   */
-  @Deprecated
-  long getBufferedPositionInPeriod();
-  /**
-   * Returns an estimate of the percentage in the current period up to which data is buffered, or 0
-   * if no estimate is available.
-   */
-  @Deprecated
-  int getBufferedPercentageInPeriod();
-  // MediaWindow based.
  /**
-   * Returns the index of the seek window associated with the current period, or
+   * Returns the index of the window associated with the current period, or {@link C#INDEX_UNSET} if
-   * {@link C#INDEX_UNSET} if the timeline is not set.
+   * the timeline is not set.
   */
  int getCurrentWindowIndex();
@@ -436,8 +370,8 @@ public interface ExoPlayer {
  long getDuration();
  /**
-   * Returns the playback position in the current seek window, in milliseconds, or
+   * Returns the playback position in the current window, in milliseconds, or {@link C#TIME_UNSET}
-   * {@link C#TIME_UNSET} if the timeline is not set.
+   * if the timeline is not set.
   */
  long getCurrentPosition();

--- a/library/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java
+++ b/library/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java
@@ -37,12 +37,14 @@ import java.util.concurrent.CopyOnWriteArraySet;
  private final Handler eventHandler;
  private final ExoPlayerImplInternal internalPlayer;
  private final CopyOnWriteArraySet<EventListener> listeners;
+  private final Timeline.Window window;
+  private final Timeline.Period period;
  private boolean playWhenReady;
  private int playbackState;
  private int pendingSeekAcks;
  private boolean isLoading;
-  private MediaTimeline timeline;
+  private Timeline timeline;
  private Object manifest;
  // Playback information when there is no pending seek/set source operation.
@@ -68,6 +70,8 @@ import java.util.concurrent.CopyOnWriteArraySet;
    this.playWhenReady = false;
    this.playbackState = STATE_IDLE;
    this.listeners = new CopyOnWriteArraySet<>();
+    window = new Timeline.Window();
+    period = new Timeline.Period();
    eventHandler = new Handler() {
      @Override
      public void handleMessage(Message msg) {
@@ -127,30 +131,6 @@ import java.util.concurrent.CopyOnWriteArraySet;
  }
  @Override
-  public void seekInCurrentPeriod(long positionMs) {
-    seekInPeriod(getCurrentPeriodIndex(), positionMs);
-  }
-  @Override
-  public void seekToDefaultPositionForPeriod(int periodIndex) {
-    seekInPeriod(periodIndex, C.TIME_UNSET);
-  }
-  @Override
-  public void seekInPeriod(int periodIndex, long positionMs) {
-    boolean seekToDefaultPosition = positionMs == C.TIME_UNSET;
-    maskingPeriodIndex = periodIndex;
-    maskingPositionMs = seekToDefaultPosition ? 0 : positionMs;
-    pendingSeekAcks++;
-    internalPlayer.seekTo(periodIndex, seekToDefaultPosition ? C.TIME_UNSET : positionMs * 1000);
-    if (!seekToDefaultPosition) {
-      for (EventListener listener : listeners) {
-        listener.onPositionDiscontinuity(periodIndex, positionMs);
-      }
-    }
-  }
-  @Override
  public void seekToDefaultPosition() {
    seekToDefaultPosition(getCurrentWindowIndex());
  }
@@ -158,38 +138,38 @@ import java.util.concurrent.CopyOnWriteArraySet;
  @Override
  public void seekToDefaultPosition(int windowIndex) {
    if (timeline == null) {
-      throw new IllegalArgumentException("Windows are not yet known");
+      // TODO: Handle seeks before the timeline is set.
+      return;
    }
    Assertions.checkIndex(windowIndex, 0, timeline.getWindowCount());
-    seekToDefaultPositionForPeriod(timeline.getWindowFirstPeriodIndex(windowIndex));
+    int periodIndex = timeline.getWindow(windowIndex, window).firstPeriodIndex;
+    seekToDefaultPositionForPeriod(periodIndex);
  }
  @Override
  public void seekTo(long positionMs) {
-    MediaTimeline timeline = getCurrentTimeline();
    if (timeline == null) {
-      throw new IllegalArgumentException("Windows are not yet known");
+      // TODO: Handle seeks before the timeline is set.
+      return;
    }
-    int windowIndex = timeline.getPeriodWindowIndex(getCurrentPeriodIndex());
+    seekTo(getCurrentWindowIndex(), positionMs);
-    seekTo(windowIndex, positionMs);
  }
  @Override
  public void seekTo(int windowIndex, long positionMs) {
    if (timeline == null) {
-      throw new IllegalArgumentException("Windows are not yet known");
+      // TODO: Handle seeks before the timeline is set.
+      return;
    }
    Assertions.checkIndex(windowIndex, 0, timeline.getWindowCount());
-    int firstPeriodIndex = timeline.getWindowFirstPeriodIndex(windowIndex);
+    timeline.getWindow(windowIndex, window);
-    int lastPeriodIndex = timeline.getWindowLastPeriodIndex(windowIndex);
+    int periodIndex = window.firstPeriodIndex;
-    int periodIndex = firstPeriodIndex;
+    long periodPositionMs = window.getPositionInFirstPeriodMs() + positionMs;
-    long periodPositionMs = timeline.getWindowOffsetInFirstPeriodUs(windowIndex) / 1000
+    long periodDurationMs = timeline.getPeriod(periodIndex, period).getDurationMs();
-        + positionMs;
-    long periodDurationMs = timeline.getPeriodDurationMs(periodIndex);
    while (periodDurationMs != C.TIME_UNSET && periodPositionMs >= periodDurationMs
-        && periodIndex < lastPeriodIndex) {
+        && periodIndex < window.lastPeriodIndex) {
      periodPositionMs -= periodDurationMs;
-      periodDurationMs = timeline.getPeriodDurationMs(++periodIndex);
+      periodDurationMs = timeline.getPeriod(++periodIndex, period).getDurationMs();
    }
    seekInPeriod(periodIndex, periodPositionMs);
  }
@@ -216,54 +196,11 @@ import java.util.concurrent.CopyOnWriteArraySet;
  }
  @Override
-  @Deprecated
-  public int getCurrentPeriodIndex() {
-    return pendingSeekAcks == 0 ? playbackInfo.periodIndex : maskingPeriodIndex;
-  }
-  @Override
-  @Deprecated
-  public long getCurrentPeriodDuration() {
-    if (timeline == null) {
-      return C.TIME_UNSET;
-    }
-    return timeline.getPeriodDurationMs(getCurrentPeriodIndex());
-  }
-  @Override
-  @Deprecated
-  public long getCurrentPositionInPeriod() {
-    return pendingSeekAcks > 0 ? maskingPositionMs : C.usToMs(playbackInfo.positionUs);
-  }
-  @Override
-  @Deprecated
-  public long getBufferedPositionInPeriod() {
-    if (pendingSeekAcks == 0) {
-      return C.usToMs(playbackInfo.bufferedPositionUs);
-    } else {
-      return maskingPositionMs;
-    }
-  }
-  @Override
-  @Deprecated
-  public int getBufferedPercentageInPeriod() {
-    if (timeline == null) {
-      return 0;
-    }
-    long bufferedPosition = getBufferedPositionInPeriod();
-    long duration = getCurrentPeriodDuration();
-    return (bufferedPosition == C.TIME_UNSET || duration == C.TIME_UNSET) ? 0
-        : (int) (duration == 0 ? 100 : (bufferedPosition * 100) / duration);
-  }
-  @Override
  public int getCurrentWindowIndex() {
    if (timeline == null) {
      return C.INDEX_UNSET;
    }
-    return timeline.getPeriodWindowIndex(getCurrentPeriodIndex());
+    return timeline.getPeriod(getCurrentPeriodIndex(), period).windowIndex;
  }
  @Override
@@ -271,7 +208,7 @@ import java.util.concurrent.CopyOnWriteArraySet;
    if (timeline == null) {
      return C.TIME_UNSET;
    }
-    return C.usToMs(timeline.getWindow(getCurrentWindowIndex()).durationUs);
+    return timeline.getWindow(getCurrentWindowIndex(), window).getDurationMs();
  }
  @Override
@@ -279,14 +216,8 @@ import java.util.concurrent.CopyOnWriteArraySet;
    if (timeline == null) {
      return C.TIME_UNSET;
    }
-    int periodIndex = getCurrentPeriodIndex();
+    timeline.getPeriod(getCurrentPeriodIndex(), period);
-    int windowIndex = timeline.getPeriodWindowIndex(periodIndex);
+    return period.getPositionInWindowMs() + getCurrentPositionInPeriod();
-    long positionMs = getCurrentPositionInPeriod();
-    for (int i = timeline.getWindowFirstPeriodIndex(windowIndex); i < periodIndex; i++) {
-      positionMs += timeline.getPeriodDurationMs(i);
-    }
-    positionMs -= timeline.getWindowOffsetInFirstPeriodUs(windowIndex) / 1000;
-    return positionMs;
  }
  @Override
@@ -296,13 +227,12 @@ import java.util.concurrent.CopyOnWriteArraySet;
      return C.TIME_UNSET;
    }
    int periodIndex = getCurrentPeriodIndex();
-    int windowIndex = timeline.getPeriodWindowIndex(periodIndex);
+    timeline.getPeriod(periodIndex, period);
-    MediaWindow window = timeline.getWindow(windowIndex);
+    int windowIndex = period.windowIndex;
-    int firstPeriodIndex = timeline.getWindowFirstPeriodIndex(windowIndex);
+    timeline.getWindow(windowIndex, window);
-    int lastPeriodIndex = timeline.getWindowLastPeriodIndex(windowIndex);
+    if (window.firstPeriodIndex == periodIndex && window.lastPeriodIndex == periodIndex
-    if (firstPeriodIndex == periodIndex && lastPeriodIndex == periodIndex
+        && window.getPositionInFirstPeriodUs() == 0
-        && timeline.getWindowOffsetInFirstPeriodUs(windowIndex) == 0
+        && window.getDurationUs() == period.getDurationUs()) {
-        && window.durationUs == timeline.getPeriodDurationUs(periodIndex)) {
      return getBufferedPositionInPeriod();
    }
    return getCurrentPosition();
@@ -320,7 +250,7 @@ import java.util.concurrent.CopyOnWriteArraySet;
  }
  @Override
-  public MediaTimeline getCurrentTimeline() {
+  public Timeline getCurrentTimeline() {
    return timeline;
  }
@@ -329,6 +259,44 @@ import java.util.concurrent.CopyOnWriteArraySet;
    return manifest;
  }
+  // TODO: Remove
+  private void seekToDefaultPositionForPeriod(int periodIndex) {
+    seekInPeriod(periodIndex, C.TIME_UNSET);
+  }
+  // TODO: Remove
+  private void seekInPeriod(int periodIndex, long positionMs) {
+    boolean seekToDefaultPosition = positionMs == C.TIME_UNSET;
+    maskingPeriodIndex = periodIndex;
+    maskingPositionMs = seekToDefaultPosition ? 0 : positionMs;
+    pendingSeekAcks++;
+    internalPlayer.seekTo(periodIndex, seekToDefaultPosition ? C.TIME_UNSET : positionMs * 1000);
+    if (!seekToDefaultPosition) {
+      for (EventListener listener : listeners) {
+        listener.onPositionDiscontinuity(periodIndex, positionMs);
+      }
+    }
+  }
+  // TODO: Remove
+  private int getCurrentPeriodIndex() {
+    return pendingSeekAcks == 0 ? playbackInfo.periodIndex : maskingPeriodIndex;
+  }
+  // TODO: Remove
+  private long getCurrentPositionInPeriod() {
+    return pendingSeekAcks > 0 ? maskingPositionMs : C.usToMs(playbackInfo.positionUs);
+  }
+  // TODO: Remove
+  private long getBufferedPositionInPeriod() {
+    if (pendingSeekAcks == 0) {
+      return C.usToMs(playbackInfo.bufferedPositionUs);
+    } else {
+      return maskingPositionMs;
+    }
+  }
  // Not private so it can be called from an inner class without going through a thunk method.
  /* package */ void handleEvent(Message msg) {
    switch (msg.what) {
@@ -361,16 +329,16 @@ import java.util.concurrent.CopyOnWriteArraySet;
      case ExoPlayerImplInternal.MSG_POSITION_DISCONTINUITY: {
        if (pendingSeekAcks == 0) {
          playbackInfo = (ExoPlayerImplInternal.PlaybackInfo) msg.obj;
+          long positionMs = C.usToMs(playbackInfo.startPositionUs);
          for (EventListener listener : listeners) {
-            listener.onPositionDiscontinuity(playbackInfo.periodIndex,
+            listener.onPositionDiscontinuity(playbackInfo.periodIndex, positionMs);
-                C.usToMs(playbackInfo.startPositionUs));
          }
        }
        break;
      }
      case ExoPlayerImplInternal.MSG_SOURCE_INFO_REFRESHED: {
        @SuppressWarnings("unchecked")
-        Pair<MediaTimeline, Object> timelineAndManifest = (Pair<MediaTimeline, Object>) msg.obj;
+        Pair<Timeline, Object> timelineAndManifest = (Pair<Timeline, Object>) msg.obj;
        timeline = timelineAndManifest.first;
        manifest = timelineAndManifest.second;
        for (EventListener listener : listeners) {

--- a/library/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java
+++ b/library/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java
@@ -106,6 +106,8 @@ import java.io.IOException;
  private final Handler handler;
  private final HandlerThread internalPlaybackThread;
  private final Handler eventHandler;
+  private final Timeline.Window window;
+  private final Timeline.Period period;
  private PlaybackInfo playbackInfo;
  private Renderer rendererMediaClockSource;
@@ -126,11 +128,11 @@ import java.io.IOException;
  private boolean isTimelineReady;
  private boolean isTimelineEnded;
  private int bufferAheadPeriodCount;
-  private Period playingPeriod;
+  private MediaPeriodHolder playingPeriodHolder;
-  private Period readingPeriod;
+  private MediaPeriodHolder readingPeriodHolder;
-  private Period loadingPeriod;
+  private MediaPeriodHolder loadingPeriodHolder;
-  private MediaTimeline timeline;
+  private Timeline timeline;
  public ExoPlayerImplInternal(Renderer[] renderers, TrackSelector trackSelector,
      LoadControl loadControl, boolean playWhenReady, Handler eventHandler,
@@ -150,6 +152,8 @@ import java.io.IOException;
    }
    standaloneMediaClock = new StandaloneMediaClock();
    enabledRenderers = new Renderer[0];
+    window = new Timeline.Window();
+    period = new Timeline.Period();
    trackSelector.init(this);
    // Note: The documentation for Process.THREAD_PRIORITY_AUDIO that states "Applications can
@@ -220,7 +224,7 @@ import java.io.IOException;
  // MediaSource.Listener implementation.
  @Override
-  public void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+  public void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
    handler.obtainMessage(MSG_REFRESH_SOURCE_INFO, Pair.create(timeline, manifest)).sendToTarget();
  }
@@ -278,7 +282,7 @@ import java.io.IOException;
          return true;
        }
        case MSG_REFRESH_SOURCE_INFO: {
-          handleSourceInfoRefreshed((Pair<MediaTimeline, Object>) msg.obj);
+          handleSourceInfoRefreshed((Pair<Timeline, Object>) msg.obj);
          return true;
        }
        case MSG_SOURCE_CONTINUE_LOADING_REQUESTED: {
@@ -375,13 +379,12 @@ import java.io.IOException;
  }
  private void updatePlaybackPositions() throws ExoPlaybackException {
-    if (playingPeriod == null) {
+    if (playingPeriodHolder == null) {
      return;
    }
-    MediaPeriod mediaPeriod = playingPeriod.mediaPeriod;
    // Update the playback position.
-    long periodPositionUs = mediaPeriod.readDiscontinuity();
+    long periodPositionUs = playingPeriodHolder.mediaPeriod.readDiscontinuity();
    if (periodPositionUs != C.TIME_UNSET) {
      resetRendererPosition(periodPositionUs);
    } else {
@@ -391,23 +394,24 @@ import java.io.IOException;
      } else {
        rendererPositionUs = standaloneMediaClock.getPositionUs();
      }
-      periodPositionUs = rendererPositionUs - playingPeriod.rendererPositionOffsetUs;
+      periodPositionUs = rendererPositionUs - playingPeriodHolder.rendererPositionOffsetUs;
    }
    playbackInfo.positionUs = periodPositionUs;
    elapsedRealtimeUs = SystemClock.elapsedRealtime() * 1000;
    // Update the buffered position.
    long bufferedPositionUs = enabledRenderers.length == 0 ? C.TIME_END_OF_SOURCE
-        : mediaPeriod.getBufferedPositionUs();
+        : playingPeriodHolder.mediaPeriod.getBufferedPositionUs();
    playbackInfo.bufferedPositionUs = bufferedPositionUs == C.TIME_END_OF_SOURCE
-        ? timeline.getPeriodDurationUs(playingPeriod.index) : bufferedPositionUs;
+        ? timeline.getPeriod(playingPeriodHolder.index, period).getDurationUs()
+        : bufferedPositionUs;
  }
  private void doSomeWork() throws ExoPlaybackException, IOException {
    long operationStartTimeMs = SystemClock.elapsedRealtime();
    updatePeriods();
-    if (playingPeriod == null) {
+    if (playingPeriodHolder == null) {
      // We're still waiting for the first period to be prepared.
      maybeThrowPeriodPrepareError();
      scheduleNextWork(operationStartTimeMs, PREPARING_SOURCE_INTERVAL_MS);
@@ -438,10 +442,11 @@ import java.io.IOException;
      maybeThrowPeriodPrepareError();
    }
-    long playingPeriodDuration = timeline.getPeriodDurationUs(playingPeriod.index);
+    long playingPeriodDurationUs = timeline.getPeriod(playingPeriodHolder.index, period)
+        .getDurationUs();
    if (allRenderersEnded
-        && (playingPeriodDuration == C.TIME_UNSET
+        && (playingPeriodDurationUs == C.TIME_UNSET
-        || playingPeriodDuration <= playbackInfo.positionUs)
+        || playingPeriodDurationUs <= playbackInfo.positionUs)
        && isTimelineEnded) {
      setState(ExoPlayer.STATE_ENDED);
      stopRenderers();
@@ -526,27 +531,27 @@ import java.io.IOException;
    setState(ExoPlayer.STATE_BUFFERING);
    if (periodPositionUs == C.TIME_UNSET
-        || (readingPeriod != playingPeriod && (periodIndex == playingPeriod.index
+        || (readingPeriodHolder != playingPeriodHolder && (periodIndex == playingPeriodHolder.index
-        || (readingPeriod != null && periodIndex == readingPeriod.index)))) {
+        || (readingPeriodHolder != null && periodIndex == readingPeriodHolder.index)))) {
      // Clear the timeline because either the seek position is not known, or a renderer is reading
      // ahead to the next period and the seek is to either the playing or reading period.
      periodIndex = C.INDEX_UNSET;
    }
    // Clear the timeline, but keep the requested period if it is already prepared.
-    Period period = playingPeriod;
+    MediaPeriodHolder periodHolder = playingPeriodHolder;
-    Period newPlayingPeriod = null;
+    MediaPeriodHolder newPlayingPeriodHolder = null;
-    while (period != null) {
+    while (periodHolder != null) {
-      if (period.index == periodIndex && period.prepared) {
+      if (periodHolder.index == periodIndex && periodHolder.prepared) {
-        newPlayingPeriod = period;
+        newPlayingPeriodHolder = periodHolder;
      } else {
-        period.release();
+        periodHolder.release();
      }
-      period = period.nextPeriod;
+      periodHolder = periodHolder.next;
    }
    // Disable all the renderers if the period is changing.
-    if (newPlayingPeriod != playingPeriod) {
+    if (newPlayingPeriodHolder != playingPeriodHolder) {
      for (Renderer renderer : enabledRenderers) {
        renderer.disable();
      }
@@ -557,21 +562,21 @@ import java.io.IOException;
    // Update loaded periods.
    bufferAheadPeriodCount = 0;
-    if (newPlayingPeriod != null) {
+    if (newPlayingPeriodHolder != null) {
-      newPlayingPeriod.nextPeriod = null;
+      newPlayingPeriodHolder.next = null;
-      setPlayingPeriod(newPlayingPeriod);
+      setPlayingPeriodHolder(newPlayingPeriodHolder);
      updateTimelineState();
-      readingPeriod = playingPeriod;
+      readingPeriodHolder = playingPeriodHolder;
-      loadingPeriod = playingPeriod;
+      loadingPeriodHolder = playingPeriodHolder;
-      if (playingPeriod.hasEnabledTracks) {
+      if (playingPeriodHolder.hasEnabledTracks) {
-        periodPositionUs = playingPeriod.mediaPeriod.seekToUs(periodPositionUs);
+        periodPositionUs = playingPeriodHolder.mediaPeriod.seekToUs(periodPositionUs);
      }
      resetRendererPosition(periodPositionUs);
      maybeContinueLoading();
    } else {
-      playingPeriod = null;
+      playingPeriodHolder = null;
-      readingPeriod = null;
+      readingPeriodHolder = null;
-      loadingPeriod = null;
+      loadingPeriodHolder = null;
      if (periodPositionUs != C.TIME_UNSET) {
        resetRendererPosition(periodPositionUs);
      }
@@ -582,7 +587,8 @@ import java.io.IOException;
  }
  private void resetRendererPosition(long periodPositionUs) throws ExoPlaybackException {
-    long periodOffsetUs = playingPeriod == null ? 0 : playingPeriod.rendererPositionOffsetUs;
+    long periodOffsetUs = playingPeriodHolder == null ? 0
+        : playingPeriodHolder.rendererPositionOffsetUs;
    rendererPositionUs = periodOffsetUs + periodPositionUs;
    standaloneMediaClock.setPositionUs(rendererPositionUs);
    for (Renderer renderer : enabledRenderers) {
@@ -624,12 +630,13 @@ import java.io.IOException;
      mediaSource.releaseSource();
      mediaSource = null;
    }
-    releasePeriodsFrom(playingPeriod != null ? playingPeriod : loadingPeriod);
+    releasePeriodHoldersFrom(playingPeriodHolder != null ? playingPeriodHolder
+        : loadingPeriodHolder);
    isTimelineReady = false;
    isTimelineEnded = false;
-    playingPeriod = null;
+    playingPeriodHolder = null;
-    readingPeriod = null;
+    readingPeriodHolder = null;
-    loadingPeriod = null;
+    loadingPeriodHolder = null;
    timeline = null;
    bufferAheadPeriodCount = 0;
    loadControl.onTracksDisabled();
@@ -660,43 +667,43 @@ import java.io.IOException;
  }
  private void reselectTracksInternal() throws ExoPlaybackException {
-    if (playingPeriod == null) {
+    if (playingPeriodHolder == null) {
      // We don't have tracks yet, so we don't care.
      return;
    }
    // Reselect tracks on each period in turn, until the selection changes.
-    Period period = playingPeriod;
+    MediaPeriodHolder periodHolder = playingPeriodHolder;
    boolean selectionsChangedForReadPeriod = true;
    while (true) {
-      if (period == null || !period.prepared) {
+      if (periodHolder == null || !periodHolder.prepared) {
        // The reselection did not change any prepared periods.
        return;
      }
-      if (period.selectTracks()) {
+      if (periodHolder.selectTracks()) {
        // Selected tracks have changed for this period.
        break;
      }
-      if (period == readingPeriod) {
+      if (periodHolder == readingPeriodHolder) {
        // The track reselection didn't affect any period that has been read.
        selectionsChangedForReadPeriod = false;
      }
-      period = period.nextPeriod;
+      periodHolder = periodHolder.next;
    }
    if (selectionsChangedForReadPeriod) {
      // Release everything after the playing period because a renderer may have read data from a
      // track whose selection has now changed.
-      releasePeriodsFrom(playingPeriod.nextPeriod);
+      releasePeriodHoldersFrom(playingPeriodHolder.next);
-      playingPeriod.nextPeriod = null;
+      playingPeriodHolder.next = null;
-      readingPeriod = playingPeriod;
+      readingPeriodHolder = playingPeriodHolder;
-      loadingPeriod = playingPeriod;
+      loadingPeriodHolder = playingPeriodHolder;
      bufferAheadPeriodCount = 0;
      // Update streams for the new selection, recreating all streams if reading ahead.
-      boolean recreateStreams = readingPeriod != playingPeriod;
+      boolean recreateStreams = readingPeriodHolder != playingPeriodHolder;
      boolean[] streamResetFlags = new boolean[renderers.length];
-      long periodPositionUs = playingPeriod.updatePeriodTrackSelection(playbackInfo.positionUs,
+      long periodPositionUs = playingPeriodHolder.updatePeriodTrackSelection(
-          loadControl, recreateStreams, streamResetFlags);
+          playbackInfo.positionUs, loadControl, recreateStreams, streamResetFlags);
      if (periodPositionUs != playbackInfo.positionUs) {
        playbackInfo.positionUs = periodPositionUs;
        resetRendererPosition(periodPositionUs);
@@ -707,7 +714,7 @@ import java.io.IOException;
      for (int i = 0; i < renderers.length; i++) {
        Renderer renderer = renderers[i];
        rendererWasEnabledFlags[i] = renderer.getState() != Renderer.STATE_DISABLED;
-        SampleStream sampleStream = playingPeriod.sampleStreams[i];
+        SampleStream sampleStream = playingPeriodHolder.sampleStreams[i];
        if (sampleStream != null) {
          enabledRendererCount++;
        }
@@ -732,21 +739,21 @@ import java.io.IOException;
          }
        }
      }
-      trackSelector.onSelectionActivated(playingPeriod.trackSelectionData);
+      trackSelector.onSelectionActivated(playingPeriodHolder.trackSelectionData);
      enableRenderers(rendererWasEnabledFlags, enabledRendererCount);
    } else {
      // Release and re-prepare/buffer periods after the one whose selection changed.
-      loadingPeriod = period;
+      loadingPeriodHolder = periodHolder;
-      period = loadingPeriod.nextPeriod;
+      periodHolder = loadingPeriodHolder.next;
-      while (period != null) {
+      while (periodHolder != null) {
-        period.release();
+        periodHolder.release();
-        period = period.nextPeriod;
+        periodHolder = periodHolder.next;
        bufferAheadPeriodCount--;
      }
-      loadingPeriod.nextPeriod = null;
+      loadingPeriodHolder.next = null;
      long loadingPeriodPositionUs = Math.max(0,
-          rendererPositionUs - loadingPeriod.rendererPositionOffsetUs);
+          rendererPositionUs - loadingPeriodHolder.rendererPositionOffsetUs);
-      loadingPeriod.updatePeriodTrackSelection(loadingPeriodPositionUs, loadControl, false);
+      loadingPeriodHolder.updatePeriodTrackSelection(loadingPeriodPositionUs, loadControl, false);
    }
    maybeContinueLoading();
    updatePlaybackPositions();
@@ -754,67 +761,72 @@ import java.io.IOException;
  }
  private boolean haveSufficientBuffer(boolean rebuffering) {
-    if (loadingPeriod == null) {
+    if (loadingPeriodHolder == null) {
      return false;
    }
-    long loadingPeriodPositionUs = rendererPositionUs - loadingPeriod.rendererPositionOffsetUs;
+    long loadingPeriodPositionUs = rendererPositionUs
+        - loadingPeriodHolder.rendererPositionOffsetUs;
    long loadingPeriodBufferedPositionUs =
-        !loadingPeriod.prepared ? 0 : loadingPeriod.mediaPeriod.getBufferedPositionUs();
+        !loadingPeriodHolder.prepared ? 0 : loadingPeriodHolder.mediaPeriod.getBufferedPositionUs();
    if (loadingPeriodBufferedPositionUs == C.TIME_END_OF_SOURCE) {
-      if (loadingPeriod.isLast) {
+      if (loadingPeriodHolder.isLast) {
        return true;
      }
-      loadingPeriodBufferedPositionUs = timeline.getPeriodDurationUs(loadingPeriod.index);
+      loadingPeriodBufferedPositionUs = timeline.getPeriod(loadingPeriodHolder.index, period)
+          .getDurationUs();
    }
    return loadControl.shouldStartPlayback(
        loadingPeriodBufferedPositionUs - loadingPeriodPositionUs, rebuffering);
  }
  private void maybeThrowPeriodPrepareError() throws IOException {
-    if (loadingPeriod != null && !loadingPeriod.prepared
+    if (loadingPeriodHolder != null && !loadingPeriodHolder.prepared
-        && (readingPeriod == null || readingPeriod.nextPeriod == loadingPeriod)) {
+        && (readingPeriodHolder == null || readingPeriodHolder.next == loadingPeriodHolder)) {
      for (Renderer renderer : enabledRenderers) {
        if (!renderer.hasReadStreamToEnd()) {
          return;
        }
      }
-      loadingPeriod.mediaPeriod.maybeThrowPrepareError();
+      loadingPeriodHolder.mediaPeriod.maybeThrowPrepareError();
    }
  }
-  private void handleSourceInfoRefreshed(Pair<MediaTimeline, Object> timelineAndManifest)
+  private void handleSourceInfoRefreshed(Pair<Timeline, Object> timelineAndManifest)
      throws ExoPlaybackException, IOException {
    eventHandler.obtainMessage(MSG_SOURCE_INFO_REFRESHED, timelineAndManifest).sendToTarget();
-    MediaTimeline oldTimeline = this.timeline;
+    Timeline oldTimeline = this.timeline;
    this.timeline = timelineAndManifest.first;
    // Update the loaded periods to take into account the new timeline.
-    if (playingPeriod != null) {
+    if (playingPeriodHolder != null) {
-      int index = timeline.getIndexOfPeriod(playingPeriod.id);
+      int index = timeline.getIndexOfPeriod(playingPeriodHolder.uid);
      if (index == C.INDEX_UNSET) {
-        attemptRestart(timeline, oldTimeline, playingPeriod.index);
+        attemptRestart(timeline, oldTimeline, playingPeriodHolder.index);
        return;
      }
      // The playing period is also in the new timeline. Update the index for each loaded period
      // until a period is found that does not match the old timeline.
-      playingPeriod.setIndex(timeline, index);
+      timeline.getPeriod(index, period, true);
+      playingPeriodHolder.setIndex(timeline, timeline.getWindow(period.windowIndex, window),
+          index);
-      Period previousPeriod = playingPeriod;
+      MediaPeriodHolder previousPeriod = playingPeriodHolder;
      boolean seenReadingPeriod = false;
      bufferAheadPeriodCount = 0;
-      while (previousPeriod.nextPeriod != null) {
+      while (previousPeriod.next != null) {
-        Period period = previousPeriod.nextPeriod;
+        MediaPeriodHolder periodHolder = previousPeriod.next;
        index++;
-        if (!period.id.equals(timeline.getPeriodId(index))) {
+        timeline.getPeriod(index, period, true);
+        if (!periodHolder.uid.equals(period.uid)) {
          if (!seenReadingPeriod) {
            // Renderers may have read a period that has been removed, so release all loaded periods
            // and seek to the current position of the playing period index.
-            index = playingPeriod.index;
+            index = playingPeriodHolder.index;
-            releasePeriodsFrom(playingPeriod);
+            releasePeriodHoldersFrom(playingPeriodHolder);
-            playingPeriod = null;
+            playingPeriodHolder = null;
-            readingPeriod = null;
+            readingPeriodHolder = null;
-            loadingPeriod = null;
+            loadingPeriodHolder = null;
            long newPositionUs = seekToPeriodPosition(index, playbackInfo.positionUs);
            if (newPositionUs != playbackInfo.positionUs) {
              playbackInfo = new PlaybackInfo(index, newPositionUs);
@@ -824,36 +836,39 @@ import java.io.IOException;
          }
          // Update the loading period to be the latest period that is still valid.
-          loadingPeriod = previousPeriod;
+          loadingPeriodHolder = previousPeriod;
-          loadingPeriod.nextPeriod = null;
+          loadingPeriodHolder.next = null;
          // Release the rest of the timeline.
-          releasePeriodsFrom(period);
+          releasePeriodHoldersFrom(periodHolder);
          break;
        }
        bufferAheadPeriodCount++;
-        period.setIndex(timeline, index);
+        int windowIndex = timeline.getPeriod(index, period).windowIndex;
-        if (period == readingPeriod) {
+        periodHolder.setIndex(timeline, timeline.getWindow(windowIndex, window), index);
+        if (periodHolder == readingPeriodHolder) {
          seenReadingPeriod = true;
        }
-        previousPeriod = period;
+        previousPeriod = periodHolder;
      }
-    } else if (loadingPeriod != null) {
+    } else if (loadingPeriodHolder != null) {
-      Object id = loadingPeriod.id;
+      Object uid = loadingPeriodHolder.uid;
-      int index = timeline.getIndexOfPeriod(id);
+      int index = timeline.getIndexOfPeriod(uid);
      if (index == C.INDEX_UNSET) {
-        attemptRestart(timeline, oldTimeline, loadingPeriod.index);
+        attemptRestart(timeline, oldTimeline, loadingPeriodHolder.index);
        return;
      } else {
-        loadingPeriod.setIndex(timeline, index);
+        int windowIndex = timeline.getPeriod(index, this.period).windowIndex;
+        loadingPeriodHolder.setIndex(timeline, timeline.getWindow(windowIndex, window),
+            index);
      }
    }
    // TODO[playlists]: Signal the identifier discontinuity, even if the index hasn't changed.
    if (oldTimeline != null) {
-      int newPlayingIndex = playingPeriod != null ? playingPeriod.index
+      int newPlayingIndex = playingPeriodHolder != null ? playingPeriodHolder.index
-          : loadingPeriod != null ? loadingPeriod.index : C.INDEX_UNSET;
+          : loadingPeriodHolder != null ? loadingPeriodHolder.index : C.INDEX_UNSET;
      if (newPlayingIndex != C.INDEX_UNSET
          && newPlayingIndex != playbackInfo.periodIndex) {
        playbackInfo = new PlaybackInfo(newPlayingIndex, playbackInfo.positionUs);
@@ -863,12 +878,13 @@ import java.io.IOException;
    }
  }
-  private void attemptRestart(MediaTimeline newTimeline, MediaTimeline oldTimeline,
+  private void attemptRestart(Timeline newTimeline, Timeline oldTimeline,
      int oldPeriodIndex) throws ExoPlaybackException {
    int newPeriodIndex = C.INDEX_UNSET;
    while (newPeriodIndex == C.INDEX_UNSET
        && oldPeriodIndex < oldTimeline.getPeriodCount() - 1) {
-      newPeriodIndex = newTimeline.getIndexOfPeriod(oldTimeline.getPeriodId(++oldPeriodIndex));
+      newPeriodIndex =
+          newTimeline.getIndexOfPeriod(oldTimeline.getPeriod(++oldPeriodIndex, period, true).uid);
    }
    if (newPeriodIndex == C.INDEX_UNSET) {
      // We failed to find a replacement period. Stop the player.
@@ -877,11 +893,11 @@ import java.io.IOException;
    }
    // Release all loaded periods.
-    releasePeriodsFrom(playingPeriod);
+    releasePeriodHoldersFrom(playingPeriodHolder);
    bufferAheadPeriodCount = 0;
-    playingPeriod = null;
+    playingPeriodHolder = null;
-    readingPeriod = null;
+    readingPeriodHolder = null;
-    loadingPeriod = null;
+    loadingPeriodHolder = null;
    // Find the default initial position in the window and seek to it.
    Pair<Integer, Long> defaultPosition = getDefaultPosition(newPeriodIndex);
@@ -893,14 +909,16 @@ import java.io.IOException;
  }
  private Pair<Integer, Long> getDefaultPosition(int periodIndex) {
-    int windowIndex = timeline.getPeriodWindowIndex(periodIndex);
+    timeline.getPeriod(periodIndex, period);
-    periodIndex = timeline.getWindowFirstPeriodIndex(windowIndex);
+    timeline.getWindow(period.windowIndex, window);
-    int maxPeriodIndex = timeline.getWindowLastPeriodIndex(windowIndex);
+    periodIndex = window.firstPeriodIndex;
-    long periodPositionUs = timeline.getWindowOffsetInFirstPeriodUs(windowIndex)
+    long periodPositionUs = window.getPositionInFirstPeriodUs()
-        + timeline.getWindow(windowIndex).defaultStartPositionUs;
+        + window.getDefaultStartPositionUs();
-    while (periodIndex < maxPeriodIndex
+    timeline.getPeriod(periodIndex, period);
-        && periodPositionUs > timeline.getPeriodDurationUs(periodIndex)) {
+    while (periodIndex < window.lastPeriodIndex
-      periodPositionUs -= timeline.getPeriodDurationUs(periodIndex++);
+        && periodPositionUs > period.getDurationMs()) {
+      periodPositionUs -= period.getDurationUs();
+      timeline.getPeriod(periodIndex++, period);
    }
    return Pair.create(periodIndex, periodPositionUs);
  }
@@ -912,18 +930,21 @@ import java.io.IOException;
      return;
    }
-    if (loadingPeriod == null || (loadingPeriod.isFullyBuffered() && !loadingPeriod.isLast
+    if (loadingPeriodHolder == null
+        || (loadingPeriodHolder.isFullyBuffered() && !loadingPeriodHolder.isLast
        && bufferAheadPeriodCount < MAXIMUM_BUFFER_AHEAD_PERIODS)) {
      // We don't have a loading period or it's fully loaded, so try and create the next one.
-      int newLoadingPeriodIndex = loadingPeriod == null ? playbackInfo.periodIndex
+      int newLoadingPeriodIndex = loadingPeriodHolder == null ? playbackInfo.periodIndex
-          : loadingPeriod.index + 1;
+          : loadingPeriodHolder.index + 1;
      if (newLoadingPeriodIndex >= timeline.getPeriodCount()) {
        // The period is not available yet.
        mediaSource.maybeThrowSourceInfoRefreshError();
      } else {
-        long periodStartPositionUs = loadingPeriod == null ? playbackInfo.positionUs
+        int windowIndex = timeline.getPeriod(newLoadingPeriodIndex, period).windowIndex;
-            : (newLoadingPeriodIndex == timeline.getWindowFirstPeriodIndex(newLoadingPeriodIndex)
+        boolean isFirstPeriodInWindow = newLoadingPeriodIndex
-                ? C.TIME_UNSET : 0);
+            == timeline.getWindow(windowIndex, window).firstPeriodIndex;
+        long periodStartPositionUs = loadingPeriodHolder == null ? playbackInfo.positionUs
+            : (isFirstPeriodInWindow ? C.TIME_UNSET : 0);
        if (periodStartPositionUs == C.TIME_UNSET) {
          // This is the first period of a new window or we don't have a start position, so seek to
          // the default position for the window.
@@ -931,47 +952,50 @@ import java.io.IOException;
          newLoadingPeriodIndex = defaultPosition.first;
          periodStartPositionUs = defaultPosition.second;
        }
-        MediaPeriod mediaPeriod = mediaSource.createPeriod(newLoadingPeriodIndex, this,
+        Object newPeriodUid = timeline.getPeriod(newLoadingPeriodIndex, period, true).uid;
+        MediaPeriod newMediaPeriod = mediaSource.createPeriod(newLoadingPeriodIndex, this,
            loadControl.getAllocator(), periodStartPositionUs);
-        Period newPeriod = new Period(renderers, rendererCapabilities, trackSelector, mediaSource,
+        MediaPeriodHolder newPeriodHolder = new MediaPeriodHolder(renderers, rendererCapabilities,
-            mediaPeriod, timeline.getPeriodId(newLoadingPeriodIndex), periodStartPositionUs);
+            trackSelector, mediaSource, newMediaPeriod, newPeriodUid, periodStartPositionUs);
-        newPeriod.setIndex(timeline, newLoadingPeriodIndex);
+        timeline.getWindow(windowIndex, window);
-        if (loadingPeriod != null) {
+        newPeriodHolder.setIndex(timeline, window, newLoadingPeriodIndex);
-          loadingPeriod.setNextPeriod(newPeriod);
+        if (loadingPeriodHolder != null) {
-          newPeriod.rendererPositionOffsetUs = loadingPeriod.rendererPositionOffsetUs
+          loadingPeriodHolder.setNext(newPeriodHolder);
-              + timeline.getPeriodDurationUs(loadingPeriod.index);
+          newPeriodHolder.rendererPositionOffsetUs = loadingPeriodHolder.rendererPositionOffsetUs
+              + timeline.getPeriod(loadingPeriodHolder.index, period).getDurationUs();
        }
        bufferAheadPeriodCount++;
-        loadingPeriod = newPeriod;
+        loadingPeriodHolder = newPeriodHolder;
        setIsLoading(true);
      }
    }
-    if (loadingPeriod == null || loadingPeriod.isFullyBuffered()) {
+    if (loadingPeriodHolder == null || loadingPeriodHolder.isFullyBuffered()) {
      setIsLoading(false);
-    } else if (loadingPeriod != null && loadingPeriod.needsContinueLoading) {
+    } else if (loadingPeriodHolder != null && loadingPeriodHolder.needsContinueLoading) {
      maybeContinueLoading();
    }
-    if (playingPeriod == null) {
+    if (playingPeriodHolder == null) {
      // We're waiting for the first period to be prepared.
      return;
    }
    // Update the playing and reading periods.
-    while (playingPeriod != readingPeriod && playingPeriod.nextPeriod != null
+    while (playingPeriodHolder != readingPeriodHolder && playingPeriodHolder.next != null
-        && rendererPositionUs >= playingPeriod.nextPeriod.rendererPositionOffsetUs) {
+        && rendererPositionUs >= playingPeriodHolder.next.rendererPositionOffsetUs) {
      // All enabled renderers' streams have been read to the end, and the playback position reached
      // the end of the playing period, so advance playback to the next period.
-      playingPeriod.release();
+      playingPeriodHolder.release();
-      setPlayingPeriod(playingPeriod.nextPeriod);
+      setPlayingPeriodHolder(playingPeriodHolder.next);
      bufferAheadPeriodCount--;
-      playbackInfo = new PlaybackInfo(playingPeriod.index, playingPeriod.startPositionUs);
+      playbackInfo = new PlaybackInfo(playingPeriodHolder.index,
+          playingPeriodHolder.startPositionUs);
      updatePlaybackPositions();
      eventHandler.obtainMessage(MSG_POSITION_DISCONTINUITY, playbackInfo).sendToTarget();
    }
    updateTimelineState();
-    if (readingPeriod == null) {
+    if (readingPeriodHolder == null) {
      // The renderers have their final SampleStreams.
      return;
    }
@@ -980,10 +1004,10 @@ import java.io.IOException;
        return;
      }
    }
-    if (readingPeriod.nextPeriod != null && readingPeriod.nextPeriod.prepared) {
+    if (readingPeriodHolder.next != null && readingPeriodHolder.next.prepared) {
-      TrackSelectionArray oldTrackSelections = readingPeriod.trackSelections;
+      TrackSelectionArray oldTrackSelections = readingPeriodHolder.trackSelections;
-      readingPeriod = readingPeriod.nextPeriod;
+      readingPeriodHolder = readingPeriodHolder.next;
-      TrackSelectionArray newTrackSelections = readingPeriod.trackSelections;
+      TrackSelectionArray newTrackSelections = readingPeriodHolder.trackSelections;
      for (int i = 0; i < renderers.length; i++) {
        Renderer renderer = renderers[i];
        TrackSelection oldSelection = oldTrackSelections.get(i);
@@ -996,8 +1020,8 @@ import java.io.IOException;
            for (int j = 0; j < formats.length; j++) {
              formats[j] = newSelection.getFormat(j);
            }
-            renderer.replaceStream(formats, readingPeriod.sampleStreams[i],
+            renderer.replaceStream(formats, readingPeriodHolder.sampleStreams[i],
-                readingPeriod.rendererPositionOffsetUs);
+                readingPeriodHolder.rendererPositionOffsetUs);
          } else {
            // The renderer will be disabled when transitioning to playing the next period. Mark the
            // SampleStream as final to play out any remaining data.
@@ -1005,8 +1029,8 @@ import java.io.IOException;
          }
        }
      }
-    } else if (readingPeriod.isLast) {
+    } else if (readingPeriodHolder.isLast) {
-      readingPeriod = null;
+      readingPeriodHolder = null;
      for (Renderer renderer : enabledRenderers) {
        renderer.setCurrentStreamIsFinal();
      }
@@ -1014,18 +1038,19 @@ import java.io.IOException;
  }
  private void handlePeriodPrepared(MediaPeriod period) throws ExoPlaybackException {
-    if (loadingPeriod == null || loadingPeriod.mediaPeriod != period) {
+    if (loadingPeriodHolder == null || loadingPeriodHolder.mediaPeriod != period) {
      // Stale event.
      return;
    }
-    loadingPeriod.handlePrepared(loadingPeriod.startPositionUs, loadControl);
+    loadingPeriodHolder.handlePrepared(loadingPeriodHolder.startPositionUs, loadControl);
-    if (playingPeriod == null) {
+    if (playingPeriodHolder == null) {
      // This is the first prepared period, so start playing it.
-      readingPeriod = loadingPeriod;
+      readingPeriodHolder = loadingPeriodHolder;
-      setPlayingPeriod(readingPeriod);
+      setPlayingPeriodHolder(readingPeriodHolder);
      if (playbackInfo.startPositionUs == C.TIME_UNSET) {
        // Update the playback info when seeking to a default position.
-        playbackInfo = new PlaybackInfo(playingPeriod.index, playingPeriod.startPositionUs);
+        playbackInfo = new PlaybackInfo(playingPeriodHolder.index,
+            playingPeriodHolder.startPositionUs);
        resetRendererPosition(playbackInfo.startPositionUs);
        updatePlaybackPositions();
        eventHandler.obtainMessage(MSG_POSITION_DISCONTINUITY, playbackInfo).sendToTarget();
@@ -1036,45 +1061,45 @@ import java.io.IOException;
  }
  private void handleContinueLoadingRequested(MediaPeriod period) {
-    if (loadingPeriod == null || loadingPeriod.mediaPeriod != period) {
+    if (loadingPeriodHolder == null || loadingPeriodHolder.mediaPeriod != period) {
      return;
    }
    maybeContinueLoading();
  }
  private void maybeContinueLoading() {
-    long nextLoadPositionUs = loadingPeriod.mediaPeriod.getNextLoadPositionUs();
+    long nextLoadPositionUs = loadingPeriodHolder.mediaPeriod.getNextLoadPositionUs();
    if (nextLoadPositionUs != C.TIME_END_OF_SOURCE) {
-      long loadingPeriodPositionUs = rendererPositionUs - loadingPeriod.rendererPositionOffsetUs
+      long loadingPeriodPositionUs = rendererPositionUs
-          + loadingPeriod.startPositionUs;
+          - loadingPeriodHolder.rendererPositionOffsetUs + loadingPeriodHolder.startPositionUs;
      long bufferedDurationUs = nextLoadPositionUs - loadingPeriodPositionUs;
      boolean continueLoading = loadControl.shouldContinueLoading(bufferedDurationUs);
      setIsLoading(continueLoading);
      if (continueLoading) {
-        loadingPeriod.needsContinueLoading = false;
+        loadingPeriodHolder.needsContinueLoading = false;
-        loadingPeriod.mediaPeriod.continueLoading(loadingPeriodPositionUs);
+        loadingPeriodHolder.mediaPeriod.continueLoading(loadingPeriodPositionUs);
      } else {
-        loadingPeriod.needsContinueLoading = true;
+        loadingPeriodHolder.needsContinueLoading = true;
      }
    } else {
      setIsLoading(false);
    }
  }
-  private void releasePeriodsFrom(Period period) {
+  private void releasePeriodHoldersFrom(MediaPeriodHolder periodHolder) {
-    while (period != null) {
+    while (periodHolder != null) {
-      period.release();
+      periodHolder.release();
-      period = period.nextPeriod;
+      periodHolder = periodHolder.next;
    }
  }
-  private void setPlayingPeriod(Period period) throws ExoPlaybackException {
+  private void setPlayingPeriodHolder(MediaPeriodHolder periodHolder) throws ExoPlaybackException {
    int enabledRendererCount = 0;
    boolean[] rendererWasEnabledFlags = new boolean[renderers.length];
    for (int i = 0; i < renderers.length; i++) {
      Renderer renderer = renderers[i];
      rendererWasEnabledFlags[i] = renderer.getState() != Renderer.STATE_DISABLED;
-      TrackSelection newSelection = period.trackSelections.get(i);
+      TrackSelection newSelection = periodHolder.trackSelections.get(i);
      if (newSelection != null) {
        // The renderer should be enabled when playing the new period.
        enabledRendererCount++;
@@ -1091,17 +1116,18 @@ import java.io.IOException;
      }
    }
-    trackSelector.onSelectionActivated(period.trackSelectionData);
+    trackSelector.onSelectionActivated(periodHolder.trackSelectionData);
-    playingPeriod = period;
+    playingPeriodHolder = periodHolder;
    enableRenderers(rendererWasEnabledFlags, enabledRendererCount);
  }
  private void updateTimelineState() {
-    long playingPeriodDurationUs = timeline.getPeriodDurationUs(playingPeriod.index);
+    long playingPeriodDurationUs = timeline.getPeriod(playingPeriodHolder.index, period)
+        .getDurationUs();
    isTimelineReady = playingPeriodDurationUs == C.TIME_UNSET
        || playbackInfo.positionUs < playingPeriodDurationUs
-        || (playingPeriod.nextPeriod != null && playingPeriod.nextPeriod.prepared);
+        || (playingPeriodHolder.next != null && playingPeriodHolder.next.prepared);
-    isTimelineEnded = playingPeriod.isLast;
+    isTimelineEnded = playingPeriodHolder.isLast;
  }
  private void enableRenderers(boolean[] rendererWasEnabledFlags, int enabledRendererCount)
@@ -1110,7 +1136,7 @@ import java.io.IOException;
    enabledRendererCount = 0;
    for (int i = 0; i < renderers.length; i++) {
      Renderer renderer = renderers[i];
-      TrackSelection newSelection = playingPeriod.trackSelections.get(i);
+      TrackSelection newSelection = playingPeriodHolder.trackSelections.get(i);
      if (newSelection != null) {
        enabledRenderers[enabledRendererCount++] = renderer;
        if (renderer.getState() == Renderer.STATE_DISABLED) {
@@ -1124,8 +1150,8 @@ import java.io.IOException;
            formats[j] = newSelection.getFormat(j);
          }
          // Enable the renderer.
-          renderer.enable(formats, playingPeriod.sampleStreams[i], rendererPositionUs, joining,
+          renderer.enable(formats, playingPeriodHolder.sampleStreams[i], rendererPositionUs,
-              playingPeriod.rendererPositionOffsetUs);
+              joining, playingPeriodHolder.rendererPositionOffsetUs);
          MediaClock mediaClock = renderer.getMediaClock();
          if (mediaClock != null) {
            if (rendererMediaClock != null) {
@@ -1145,12 +1171,12 @@ import java.io.IOException;
  }
  /**
-   * Represents a {@link MediaPeriod} with information required to play it as part of a timeline.
+   * Holds a {@link MediaPeriod} with information required to play it as part of a timeline.
   */
-  private static final class Period {
+  private static final class MediaPeriodHolder {
    public final MediaPeriod mediaPeriod;
-    public final Object id;
+    public final Object uid;
    public final SampleStream[] sampleStreams;
    public final boolean[] mayRetainStreamFlags;
@@ -1161,7 +1187,7 @@ import java.io.IOException;
    public boolean prepared;
    public boolean hasEnabledTracks;
    public long rendererPositionOffsetUs;
-    public Period nextPeriod;
+    public MediaPeriodHolder next;
    public boolean needsContinueLoading;
    private final Renderer[] renderers;
@@ -1173,27 +1199,27 @@ import java.io.IOException;
    private TrackSelectionArray trackSelections;
    private TrackSelectionArray periodTrackSelections;
-    public Period(Renderer[] renderers, RendererCapabilities[] rendererCapabilities,
+    public MediaPeriodHolder(Renderer[] renderers, RendererCapabilities[] rendererCapabilities,
-        TrackSelector trackSelector, MediaSource mediaSource, MediaPeriod mediaPeriod, Object id,
+        TrackSelector trackSelector, MediaSource mediaSource, MediaPeriod mediaPeriod, Object uid,
        long positionUs) {
      this.renderers = renderers;
      this.rendererCapabilities = rendererCapabilities;
      this.trackSelector = trackSelector;
      this.mediaSource = mediaSource;
      this.mediaPeriod = mediaPeriod;
-      this.id = Assertions.checkNotNull(id);
+      this.uid = Assertions.checkNotNull(uid);
      sampleStreams = new SampleStream[renderers.length];
      mayRetainStreamFlags = new boolean[renderers.length];
      startPositionUs = positionUs;
    }
-    public void setNextPeriod(Period nextPeriod) {
+    public void setNext(MediaPeriodHolder next) {
-      this.nextPeriod = nextPeriod;
+      this.next = next;
    }
-    public void setIndex(MediaTimeline timeline, int index) {
+    public void setIndex(Timeline timeline, Timeline.Window window, int periodIndex) {
-      this.index = index;
+      this.index = periodIndex;
-      isLast = index == timeline.getPeriodCount() - 1 && !timeline.getPeriodWindow(index).isDynamic;
+      isLast = index == timeline.getPeriodCount() - 1 && !window.isDynamic;
    }
    public boolean isFullyBuffered() {

--- a/library/src/main/java/com/google/android/exoplayer2/MediaTimeline.java
+++ b/library/src/main/java/com/google/android/exoplayer2/MediaTimeline.java
-/*
- * Copyright (C) 2016 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 com.google.android.exoplayer2;
-/**
- * The player's timeline consisting of one or more periods. Instances are immutable.
- */
-public interface MediaTimeline {
-  /**
-   * Returns the number of periods in the timeline.
-   */
-  int getPeriodCount();
-  /**
-   * Returns the absolute start time of the timeline in milliseconds.
-   */
-  long getAbsoluteStartTime();
-  /**
-   * Returns the duration of the period at {@code periodIndex} in the timeline, in milliseconds, or
-   * {@link C#TIME_UNSET} if not known.
-   *
-   * @param periodIndex The index of the period.
-   * @return The duration of the period in milliseconds, or {@link C#TIME_UNSET}.
-   */
-  long getPeriodDurationMs(int periodIndex);
-  /**
-   * Returns the duration of the period at {@code periodIndex} in the timeline, in microseconds, or
-   * {@link C#TIME_UNSET} if not known.
-   *
-   * @param periodIndex The index of the period.
-   * @return The duration of the period in microseconds, or {@link C#TIME_UNSET}.
-   */
-  long getPeriodDurationUs(int periodIndex);
-  /**
-   * Returns a unique identifier for the period at {@code periodIndex}, or {@code null} if the
-   * period at {@code periodIndex} is not known. The identifier is stable across timeline changes.
-   *
-   * @param periodIndex A period index.
-   * @return An identifier for the period, or {@code null} if the period is not known.
-   */
-  Object getPeriodId(int periodIndex);
-  /**
-   * Returns the {@link MediaWindow} to which the period with the specified index belongs.
-   *
-   * @param periodIndex The period index.
-   * @return The corresponding window.
-   */
-  MediaWindow getPeriodWindow(int periodIndex);
-  /**
-   * Returns the index of the window to which the period with the specified index belongs.
-   *
-   * @param periodIndex The period index.
-   * @return The index of the corresponding window.
-   */
-  int getPeriodWindowIndex(int periodIndex);
-  /**
-   * Returns the index of the period identified by {@code id}, or {@link C#INDEX_UNSET} if the
-   * period is not in the timeline.
-   *
-   * @param id An identifier for a period.
-   * @return The index of the period, or {@link C#INDEX_UNSET} if the period was not found.
-   */
-  int getIndexOfPeriod(Object id);
-  /**
-   * Returns the number of windows that can be accessed via {@link #getWindow(int)}.
-   */
-  int getWindowCount();
-  /**
-   * Returns the {@link MediaWindow} at the specified index.
-   *
-   * @param windowIndex The window index.
-   */
-  MediaWindow getWindow(int windowIndex);
-  /**
-   * Returns the index of the first period belonging to the window at the specified index.
-   *
-   * @param windowIndex The window index.
-   * @return The index of the first period in the window.
-   */
-  int getWindowFirstPeriodIndex(int windowIndex);
-  /**
-   * Returns the index of the last period belonging to the window at the specified index.
-   *
-   * @param windowIndex The window index.
-   * @return The index of the last period in the window.
-   */
-  int getWindowLastPeriodIndex(int windowIndex);
-  /**
-   * Returns the start position of the specified window in the first period belonging to it, in
-   * microseconds.
-   *
-   * @param windowIndex The window index.
-   * @return The start position of the window in the first period belonging to it.
-   */
-  long getWindowOffsetInFirstPeriodUs(int windowIndex);
-}
--- a/library/src/main/java/com/google/android/exoplayer2/MediaWindow.java
+++ b/library/src/main/java/com/google/android/exoplayer2/MediaWindow.java
-/*
- * Copyright (C) 2016 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 com.google.android.exoplayer2;
-/**
- * A window of available media. Instances are immutable.
- */
-public final class MediaWindow {
-  /**
-   * Creates a new window consisting of a single period with the specified duration. The default
-   * start position is zero.
-   *
-   * @param durationUs The duration of the window, in microseconds.
-   * @param isSeekable Whether seeking is supported within the window.
-   * @param isDynamic Whether this seek window may change when the timeline is updated.
-   */
-  public static MediaWindow createWindowFromZero(long durationUs, boolean isSeekable,
-      boolean isDynamic) {
-    return new MediaWindow(durationUs, isSeekable, isDynamic, 0);
-  }
-  /**
-   * The default position relative to the start of the window at which to start playback, in
-   * microseconds.
-   */
-  public final long defaultStartPositionUs;
-  /**
-   * The duration of the window in microseconds, or {@link C#TIME_UNSET} if unknown.
-   */
-  public final long durationUs;
-  /**
-   * Whether it's possible to seek within the window.
-   */
-  public final boolean isSeekable;
-  /**
-   * Whether this seek window may change when the timeline is updated.
-   */
-  public final boolean isDynamic;
-  /**
-   * @param durationUs The duration of the window in microseconds, or {@link C#TIME_UNSET} if
-   *     unknown.
-   * @param isSeekable Whether seeking is supported within the window.
-   * @param isDynamic Whether this seek window may change when the timeline is updated.
-   * @param defaultStartPositionUs The default position relative to the start of the window at which
-   *     to start playback, in microseconds.
-   */
-  public MediaWindow(long durationUs, boolean isSeekable, boolean isDynamic,
-      long defaultStartPositionUs) {
-    this.durationUs = durationUs;
-    this.isSeekable = isSeekable;
-    this.isDynamic = isDynamic;
-    this.defaultStartPositionUs = defaultStartPositionUs;
-  }
-  @Override
-  public int hashCode() {
-    int result = 17;
-    result = 31 * result + (isSeekable ? 1 : 2);
-    result = 31 * result + (isDynamic ? 1 : 2);
-    result = 31 * result + (int) defaultStartPositionUs;
-    result = 31 * result + (int) durationUs;
-    return result;
-  }
-  @Override
-  public boolean equals(Object obj) {
-    if (obj == this) {
-      return true;
-    }
-    if (obj == null || getClass() != obj.getClass()) {
-      return false;
-    }
-    MediaWindow other = (MediaWindow) obj;
-    return other.durationUs == durationUs
-        && other.isSeekable == isSeekable
-        && other.isDynamic == isDynamic
-        && other.defaultStartPositionUs == defaultStartPositionUs;
-  }
-  @Override
-  public String toString() {
-    return "MediaWindow[" + durationUs + ", " + defaultStartPositionUs + ", " + isSeekable + ", "
-        + isDynamic + "]";
-  }
-}
--- a/library/src/main/java/com/google/android/exoplayer2/SimpleExoPlayer.java
+++ b/library/src/main/java/com/google/android/exoplayer2/SimpleExoPlayer.java
@@ -392,24 +392,6 @@ public final class SimpleExoPlayer implements ExoPlayer {
  }
  @Override
-  @Deprecated
-  public void seekInCurrentPeriod(long positionMs) {
-    player.seekInCurrentPeriod(positionMs);
-  }
-  @Override
-  @Deprecated
-  public void seekToDefaultPositionForPeriod(int periodIndex) {
-    player.seekToDefaultPositionForPeriod(periodIndex);
-  }
-  @Override
-  @Deprecated
-  public void seekInPeriod(int periodIndex, long positionMs) {
-    player.seekInPeriod(periodIndex, positionMs);
-  }
-  @Override
  public void seekToDefaultPosition() {
    player.seekToDefaultPosition();
  }
@@ -450,36 +432,6 @@ public final class SimpleExoPlayer implements ExoPlayer {
  }
  @Override
-  @Deprecated
-  public int getCurrentPeriodIndex() {
-    return player.getCurrentPeriodIndex();
-  }
-  @Override
-  @Deprecated
-  public long getCurrentPeriodDuration() {
-    return player.getCurrentPeriodDuration();
-  }
-  @Override
-  @Deprecated
-  public long getCurrentPositionInPeriod() {
-    return player.getCurrentPositionInPeriod();
-  }
-  @Override
-  @Deprecated
-  public long getBufferedPositionInPeriod() {
-    return player.getBufferedPositionInPeriod();
-  }
-  @Override
-  @Deprecated
-  public int getBufferedPercentageInPeriod() {
-    return player.getBufferedPercentageInPeriod();
-  }
-  @Override
  public int getCurrentWindowIndex() {
    return player.getCurrentWindowIndex();
  }
@@ -505,7 +457,7 @@ public final class SimpleExoPlayer implements ExoPlayer {
  }
  @Override
-  public MediaTimeline getCurrentTimeline() {
+  public Timeline getCurrentTimeline() {
    return player.getCurrentTimeline();
  }

--- a/library/src/main/java/com/google/android/exoplayer2/Timeline.java
+++ b/library/src/main/java/com/google/android/exoplayer2/Timeline.java
+/*
+ * Copyright (C) 2016 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 com.google.android.exoplayer2;
+/**
+ * A media timeline. Instances are immutable.
+ */
+public abstract class Timeline {
+  /**
+   * Returns the number of windows in the timeline.
+   */
+  public abstract int getWindowCount();
+  /**
+   * Populates a {@link Window} with data for the window at the specified index. Does not populate
+   * {@link Window#id}.
+   *
+   * @param windowIndex The index of the window.
+   * @param window The {@link Window} to populate. Must not be null.
+   * @return The populated {@link Window}, for convenience.
+   */
+  public final Window getWindow(int windowIndex, Window window) {
+    return getWindow(windowIndex, window, false);
+  }
+  /**
+   * Populates a {@link Window} with data for the window at the specified index.
+   *
+   * @param windowIndex The index of the window.
+   * @param window The {@link Window} to populate. Must not be null.
+   * @param setIds Whether {@link Window#id} should be populated. If false, the field will be set to
+   * null. The caller should pass false for efficiency reasons unless the field is required.
+   * @return The populated {@link Window}, for convenience.
+   */
+  public abstract Window getWindow(int windowIndex, Window window, boolean setIds);
+  /**
+   * Returns the number of periods in the timeline.
+   */
+  public abstract int getPeriodCount();
+  /**
+   * Populates a {@link Period} with data for the period at the specified index. Does not populate
+   * {@link Period#id} and {@link Period#uid}.
+   *
+   * @param periodIndex The index of the period.
+   * @param period The {@link Period} to populate. Must not be null.
+   * @return The populated {@link Period}, for convenience.
+   */
+  public final Period getPeriod(int periodIndex, Period period) {
+    return getPeriod(periodIndex, period, false);
+  }
+  /**
+   * Populates a {@link Period} with data for the period at the specified index.
+   *
+   * @param periodIndex The index of the period.
+   * @param period The {@link Period} to populate. Must not be null.
+   * @param setIds Whether {@link Period#id} and {@link Period#uid} should be populated. If false,
+   *     the fields will be set to null. The caller should pass false for efficiency reasons unless
+   *     the fields are required.
+   * @return The populated {@link Period}, for convenience.
+   */
+  public abstract Period getPeriod(int periodIndex, Period period, boolean setIds);
+  /**
+   * Returns the index of the period identified by its unique {@code id}, or {@link C#INDEX_UNSET}
+   * if the period is not in the timeline.
+   *
+   * @param uid A unique identifier for a period.
+   * @return The index of the period, or {@link C#INDEX_UNSET} if the period was not found.
+   */
+  public abstract int getIndexOfPeriod(Object uid);
+  /**
+   * Holds information about a window of available media.
+   */
+  public static final class Window {
+    /**
+     * An identifier for the window. Not necessarily unique.
+     */
+    public Object id;
+    /**
+     * The start time of the presentation to which this window belongs in milliseconds since the
+     * epoch, or {@link C#TIME_UNSET} if unknown or not applicable. For informational purposes only.
+     */
+    public long presentationStartTimeMs;
+    /**
+     * The windows start time in milliseconds since the epoch, or {@link C#TIME_UNSET} if unknown or
+     * not applicable. For informational purposes only.
+     */
+    public long windowStartTimeMs;
+    /**
+     * Whether it's possible to seek within this window.
+     */
+    public boolean isSeekable;
+    /**
+     * Whether this window may change when the timeline is updated.
+     */
+    public boolean isDynamic;
+    /**
+     * The index of the first period that belongs to this window.
+     */
+    public int firstPeriodIndex;
+    /**
+     * The index of the last period that belongs to this window.
+     */
+    public int lastPeriodIndex;
+    private long defaultStartPositionUs;
+    private long durationUs;
+    private long positionInFirstPeriodUs;
+    /**
+     * Sets the data held by this window.
+     */
+    public Window set(Object id, long presentationStartTimeMs, long windowStartTimeMs,
+        boolean isSeekable, boolean isDynamic, long defaultStartPositionUs, long durationUs,
+        int firstPeriodIndex, int lastPeriodIndex, long positionInFirstPeriodUs) {
+      this.id = id;
+      this.presentationStartTimeMs = presentationStartTimeMs;
+      this.windowStartTimeMs = windowStartTimeMs;
+      this.isSeekable = isSeekable;
+      this.isDynamic = isDynamic;
+      this.defaultStartPositionUs = defaultStartPositionUs;
+      this.durationUs = durationUs;
+      this.firstPeriodIndex = firstPeriodIndex;
+      this.lastPeriodIndex = lastPeriodIndex;
+      this.positionInFirstPeriodUs = positionInFirstPeriodUs;
+      return this;
+    }
+    /**
+     * Returns the default position relative to the start of the window at which to begin playback,
+     * in milliseconds.
+     */
+    public long getDefaultStartPositionMs() {
+      return C.usToMs(defaultStartPositionUs);
+    }
+    /**
+     * Returns the default position relative to the start of the window at which to begin playback,
+     * in microseconds.
+     */
+    public long getDefaultStartPositionUs() {
+      return defaultStartPositionUs;
+    }
+    /**
+     * Returns the duration of the window in milliseconds, or {@link C#TIME_UNSET} if unknown.
+     */
+    public long getDurationMs() {
+      return C.usToMs(durationUs);
+    }
+    /**
+     * Returns the duration of this window in microseconds, or {@link C#TIME_UNSET} if unknown.
+     */
+    public long getDurationUs() {
+      return durationUs;
+    }
+    /**
+     * Returns the position of the start of this window relative to the start of the first period
+     * belonging to it, in milliseconds.
+     */
+    public long getPositionInFirstPeriodMs() {
+      return C.usToMs(positionInFirstPeriodUs);
+    }
+    /**
+     * Returns the position of the start of this window relative to the start of the first period
+     * belonging to it, in microseconds.
+     */
+    public long getPositionInFirstPeriodUs() {
+      return positionInFirstPeriodUs;
+    }
+  }
+  /**
+   * Holds information about a media period.
+   */
+  public static final class Period {
+    /**
+     * An identifier for the period. Not necessarily unique.
+     */
+    public Object id;
+    /**
+     * A unique identifier for the period.
+     */
+    public Object uid;
+    /**
+     * The index of the window to which this period belongs.
+     */
+    public int windowIndex;
+    private long durationUs;
+    private long positionInWindowUs;
+    /**
+     * Sets the data held by this period.
+     */
+    public Period set(Object id, Object uid, int windowIndex, long durationUs,
+        long positionInWindowUs) {
+      this.id = id;
+      this.uid = uid;
+      this.windowIndex = windowIndex;
+      this.durationUs = durationUs;
+      this.positionInWindowUs = positionInWindowUs;
+      return this;
+    }
+    /**
+     * Returns the duration of the period in milliseconds, or {@link C#TIME_UNSET} if unknown.
+     */
+    public long getDurationMs() {
+      return C.usToMs(durationUs);
+    }
+    /**
+     * Returns the duration of this period in microseconds, or {@link C#TIME_UNSET} if unknown.
+     */
+    public long getDurationUs() {
+      return durationUs;
+    }
+    /**
+     * Returns the position of the start of this period relative to the start of the window to which
+     * it belongs, in milliseconds. May be negative if the start of the period is not within the
+     * window.
+     */
+    public long getPositionInWindowMs() {
+      return C.usToMs(positionInWindowUs);
+    }
+    /**
+     * Returns the position of the start of this period relative to the start of the window to which
+     * it belongs, in microseconds. May be negative if the start of the period is not within the
+     * window.
+     */
+    public long getPositionInWindowUs() {
+      return positionInWindowUs;
+    }
+  }
+}
--- a/library/src/main/java/com/google/android/exoplayer2/source/ConcatenatingMediaSource.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/ConcatenatingMediaSource.java
@@ -17,8 +17,7 @@ package com.google.android.exoplayer2.source;
 import android.util.Pair;
 import com.google.android.exoplayer2.C;
-import com.google.android.exoplayer2.MediaTimeline;
+import com.google.android.exoplayer2.Timeline;
-import com.google.android.exoplayer2.MediaWindow;
 import com.google.android.exoplayer2.source.MediaPeriod.Callback;
 import com.google.android.exoplayer2.upstream.Allocator;
 import com.google.android.exoplayer2.util.Util;
@@ -32,18 +31,18 @@ import java.util.Map;
 public final class ConcatenatingMediaSource implements MediaSource {
  private final MediaSource[] mediaSources;
-  private final MediaTimeline[] timelines;
+  private final Timeline[] timelines;
  private final Object[] manifests;
  private final Map<MediaPeriod, Integer> sourceIndexByMediaPeriod;
-  private ConcatenatedMediaTimeline timeline;
+  private ConcatenatedTimeline timeline;
  /**
   * @param mediaSources The {@link MediaSource}s to concatenate.
   */
  public ConcatenatingMediaSource(MediaSource... mediaSources) {
    this.mediaSources = mediaSources;
-    timelines = new MediaTimeline[mediaSources.length];
+    timelines = new Timeline[mediaSources.length];
    manifests = new Object[mediaSources.length];
    sourceIndexByMediaPeriod = new HashMap<>();
  }
@@ -55,16 +54,16 @@ public final class ConcatenatingMediaSource implements MediaSource {
      mediaSources[i].prepareSource(new Listener() {
        @Override
-        public void onSourceInfoRefreshed(MediaTimeline sourceTimeline, Object manifest) {
+        public void onSourceInfoRefreshed(Timeline sourceTimeline, Object manifest) {
          timelines[index] = sourceTimeline;
          manifests[index] = manifest;
-          for (MediaTimeline timeline : timelines) {
+          for (Timeline timeline : timelines) {
            if (timeline == null) {
              // Don't invoke the listener until all sources have timelines.
              return;
            }
          }
-          timeline = new ConcatenatedMediaTimeline(timelines.clone());
+          timeline = new ConcatenatedTimeline(timelines.clone());
          listener.onSourceInfoRefreshed(timeline, manifests.clone());
        }
@@ -105,21 +104,21 @@ public final class ConcatenatingMediaSource implements MediaSource {
  }
  /**
-   * A {@link MediaTimeline} that is the concatenation of one or more {@link MediaTimeline}s.
+   * A {@link Timeline} that is the concatenation of one or more {@link Timeline}s.
   */
-  private static final class ConcatenatedMediaTimeline implements MediaTimeline {
+  private static final class ConcatenatedTimeline extends Timeline {
-    private final MediaTimeline[] timelines;
+    private final Timeline[] timelines;
    private final int[] sourcePeriodOffsets;
    private final int[] sourceWindowOffsets;
-    public ConcatenatedMediaTimeline(MediaTimeline[] timelines) {
+    public ConcatenatedTimeline(Timeline[] timelines) {
      int[] sourcePeriodOffsets = new int[timelines.length];
      int[] sourceWindowOffsets = new int[timelines.length];
      int periodCount = 0;
      int windowCount = 0;
      for (int i = 0; i < timelines.length; i++) {
-        MediaTimeline timeline = timelines[i];
+        Timeline timeline = timelines[i];
        periodCount += timeline.getPeriodCount();
        sourcePeriodOffsets[i] = periodCount;
        windowCount += timeline.getWindowCount();
@@ -131,60 +130,49 @@ public final class ConcatenatingMediaSource implements MediaSource {
    }
    @Override
-    public long getAbsoluteStartTime() {
+    public int getWindowCount() {
-      return timelines[0].getAbsoluteStartTime();
+      return sourceWindowOffsets[sourceWindowOffsets.length - 1];
-    }
-    @Override
-    public int getPeriodCount() {
-      return sourcePeriodOffsets[sourcePeriodOffsets.length - 1];
-    }
-    @Override
-    public long getPeriodDurationMs(int periodIndex) {
-      int sourceIndex = getSourceIndexForPeriod(periodIndex);
-      int firstPeriodIndexInSource = getFirstPeriodIndexInSource(sourceIndex);
-      return timelines[sourceIndex].getPeriodDurationMs(periodIndex - firstPeriodIndexInSource);
    }
    @Override
-    public long getPeriodDurationUs(int periodIndex) {
+    public Window getWindow(int windowIndex, Window window, boolean setIds) {
-      int sourceIndex = getSourceIndexForPeriod(periodIndex);
+      int sourceIndex = getSourceIndexForWindow(windowIndex);
+      int firstWindowIndexInSource = getFirstWindowIndexInSource(sourceIndex);
      int firstPeriodIndexInSource = getFirstPeriodIndexInSource(sourceIndex);
-      return timelines[sourceIndex].getPeriodDurationUs(periodIndex - firstPeriodIndexInSource);
+      timelines[sourceIndex].getWindow(windowIndex - firstWindowIndexInSource, window, setIds);
+      window.firstPeriodIndex += firstPeriodIndexInSource;
+      window.lastPeriodIndex += firstPeriodIndexInSource;
+      return window;
    }
    @Override
-    public Object getPeriodId(int periodIndex) {
+    public int getPeriodCount() {
-      int sourceIndex = getSourceIndexForPeriod(periodIndex);
+      return sourcePeriodOffsets[sourcePeriodOffsets.length - 1];
-      int firstPeriodIndexInSource = getFirstPeriodIndexInSource(periodIndex);
-      Object periodId = timelines[sourceIndex].getPeriodId(periodIndex - firstPeriodIndexInSource);
-      return Pair.create(sourceIndex, periodId);
-    }
-    @Override
-    public MediaWindow getPeriodWindow(int periodIndex) {
-      return getWindow(getPeriodWindowIndex(periodIndex));
    }
    @Override
-    public int getPeriodWindowIndex(int periodIndex) {
+    public Period getPeriod(int periodIndex, Period period, boolean setIds) {
      int sourceIndex = getSourceIndexForPeriod(periodIndex);
-      int firstPeriodIndexInSource = getFirstPeriodIndexInSource(periodIndex);
+      int firstWindowIndexInSource = getFirstWindowIndexInSource(sourceIndex);
-      return (sourceIndex > 0 ? sourceWindowOffsets[sourceIndex - 1] : 0)
+      int firstPeriodIndexInSource = getFirstPeriodIndexInSource(sourceIndex);
-          + timelines[sourceIndex].getPeriodWindowIndex(periodIndex - firstPeriodIndexInSource);
+      timelines[sourceIndex].getPeriod(periodIndex - firstPeriodIndexInSource, period, setIds);
+      period.windowIndex += firstWindowIndexInSource;
+      if (setIds) {
+        period.uid = Pair.create(sourceIndex, period.uid);
+      }
+      return period;
    }
    @Override
-    public int getIndexOfPeriod(Object id) {
+    public int getIndexOfPeriod(Object uid) {
-      if (!(id instanceof Pair)) {
+      if (!(uid instanceof Pair)) {
        return C.INDEX_UNSET;
      }
-      Pair sourceIndexAndPeriodId = (Pair) id;
+      Pair<?, ?> sourceIndexAndPeriodId = (Pair<?, ?>) uid;
      if (!(sourceIndexAndPeriodId.first instanceof Integer)) {
        return C.INDEX_UNSET;
      }
-      int sourceIndex = (int) sourceIndexAndPeriodId.first;
+      int sourceIndex = (Integer) sourceIndexAndPeriodId.first;
      Object periodId = sourceIndexAndPeriodId.second;
      if (sourceIndex < 0 || sourceIndex >= timelines.length) {
        return C.INDEX_UNSET;
@@ -194,44 +182,6 @@ public final class ConcatenatingMediaSource implements MediaSource {
          : getFirstPeriodIndexInSource(sourceIndex) + periodIndexInSource;
    }
-    @Override
-    public int getWindowCount() {
-      return sourceWindowOffsets[sourceWindowOffsets.length - 1];
-    }
-    @Override
-    public MediaWindow getWindow(int windowIndex) {
-      int sourceIndex = getSourceIndexForWindow(windowIndex);
-      int firstWindowIndexInSource = getFirstWindowIndexInSource(sourceIndex);
-      return timelines[sourceIndex].getWindow(windowIndex - firstWindowIndexInSource);
-    }
-    @Override
-    public int getWindowFirstPeriodIndex(int windowIndex) {
-      int sourceIndex = getSourceIndexForWindow(windowIndex);
-      int firstPeriodIndexInSource = getFirstPeriodIndexInSource(sourceIndex);
-      int firstWindowIndexInSource = getFirstWindowIndexInSource(sourceIndex);
-      return firstPeriodIndexInSource + timelines[sourceIndex].getWindowFirstPeriodIndex(
-          windowIndex - firstWindowIndexInSource);
-    }
-    @Override
-    public int getWindowLastPeriodIndex(int windowIndex) {
-      int sourceIndex = getSourceIndexForWindow(windowIndex);
-      int firstPeriodIndexInSource = getFirstPeriodIndexInSource(sourceIndex);
-      int firstWindowIndexInSource = getFirstWindowIndexInSource(sourceIndex);
-      return firstPeriodIndexInSource + timelines[sourceIndex].getWindowLastPeriodIndex(
-          windowIndex - firstWindowIndexInSource);
-    }
-    @Override
-    public long getWindowOffsetInFirstPeriodUs(int windowIndex) {
-      int sourceIndex = getSourceIndexForWindow(windowIndex);
-      int firstWindowIndexInSource = getFirstWindowIndexInSource(sourceIndex);
-      return timelines[sourceIndex].getWindowOffsetInFirstPeriodUs(
-          windowIndex - firstWindowIndexInSource);
-    }
    private int getSourceIndexForPeriod(int periodIndex) {
      return Util.binarySearchFloor(sourcePeriodOffsets, periodIndex, true, false) + 1;
    }

--- a/library/src/main/java/com/google/android/exoplayer2/source/ExtractorMediaPeriod.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/ExtractorMediaPeriod.java
@@ -299,7 +299,7 @@ import java.util.Arrays;
      durationUs = largestQueuedTimestampUs == Long.MIN_VALUE ? 0
          : largestQueuedTimestampUs + DEFAULT_LAST_SAMPLE_DURATION_US;
      sourceListener.onSourceInfoRefreshed(
-          new SinglePeriodMediaTimeline(durationUs, seekMap.isSeekable()), null);
+          new SinglePeriodTimeline(durationUs, seekMap.isSeekable()), null);
    }
  }
@@ -382,7 +382,7 @@ import java.util.Arrays;
    tracks = new TrackGroupArray(trackArray);
    prepared = true;
    sourceListener.onSourceInfoRefreshed(
-        new SinglePeriodMediaTimeline(durationUs, seekMap.isSeekable()), null);
+        new SinglePeriodTimeline(durationUs, seekMap.isSeekable()), null);
    callback.onPrepared(this);
  }

--- a/library/src/main/java/com/google/android/exoplayer2/source/ExtractorMediaSource.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/ExtractorMediaSource.java
@@ -18,8 +18,8 @@ package com.google.android.exoplayer2.source;
 import android.net.Uri;
 import android.os.Handler;
 import com.google.android.exoplayer2.C;
-import com.google.android.exoplayer2.MediaTimeline;
 import com.google.android.exoplayer2.ParserException;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.extractor.DefaultExtractorsFactory;
 import com.google.android.exoplayer2.extractor.Extractor;
 import com.google.android.exoplayer2.extractor.ExtractorsFactory;
@@ -92,9 +92,11 @@ public final class ExtractorMediaSource implements MediaSource, MediaSource.List
  private final int minLoadableRetryCount;
  private final Handler eventHandler;
  private final EventListener eventListener;
+  private final Timeline.Period period;
  private MediaSource.Listener sourceListener;
-  private MediaTimeline timeline;
+  private Timeline timeline;
+  private boolean timelineHasDuration;
  /**
   * @param uri The {@link Uri} of the media stream.
@@ -130,12 +132,13 @@ public final class ExtractorMediaSource implements MediaSource, MediaSource.List
    this.minLoadableRetryCount = minLoadableRetryCount;
    this.eventHandler = eventHandler;
    this.eventListener = eventListener;
+    period = new Timeline.Period();
  }
  @Override
  public void prepareSource(MediaSource.Listener listener) {
    sourceListener = listener;
-    timeline = new SinglePeriodMediaTimeline(C.TIME_UNSET, false);
+    timeline = new SinglePeriodTimeline(C.TIME_UNSET, false);
    listener.onSourceInfoRefreshed(timeline, null);
  }
@@ -166,13 +169,15 @@ public final class ExtractorMediaSource implements MediaSource, MediaSource.List
  // MediaSource.Listener implementation.
  @Override
-  public void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+  public void onSourceInfoRefreshed(Timeline newTimeline, Object manifest) {
-    if (this.timeline.getPeriodDurationUs(0) != C.TIME_UNSET
+    long newTimelineDurationUs = newTimeline.getPeriod(0, period).getDurationUs();
-        && timeline.getPeriodDurationUs(0) == C.TIME_UNSET) {
+    boolean newTimelineHasDuration = newTimelineDurationUs != C.TIME_UNSET;
+    if (timelineHasDuration && !newTimelineHasDuration) {
      // Suppress source info changes that would make the duration unknown when it is already known.
      return;
    }
-    this.timeline = timeline;
+    timeline = newTimeline;
+    timelineHasDuration = newTimelineHasDuration;
    sourceListener.onSourceInfoRefreshed(timeline, null);
  }

--- a/library/src/main/java/com/google/android/exoplayer2/source/MediaSource.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/MediaSource.java
@@ -15,7 +15,7 @@
 */
 package com.google.android.exoplayer2.source;
-import com.google.android.exoplayer2.MediaTimeline;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.source.MediaPeriod.Callback;
 import com.google.android.exoplayer2.upstream.Allocator;
 import java.io.IOException;
@@ -36,7 +36,7 @@ public interface MediaSource {
     * @param timeline The source's timeline.
     * @param manifest The loaded manifest.
     */
-    void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest);
+    void onSourceInfoRefreshed(Timeline timeline, Object manifest);
  }

--- a/library/src/main/java/com/google/android/exoplayer2/source/MergingMediaSource.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/MergingMediaSource.java
@@ -15,7 +15,7 @@
 */
 package com.google.android.exoplayer2.source;
-import com.google.android.exoplayer2.MediaTimeline;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.source.MediaPeriod.Callback;
 import com.google.android.exoplayer2.upstream.Allocator;
 import com.google.android.exoplayer2.util.Assertions;
@@ -31,6 +31,7 @@ public final class MergingMediaSource implements MediaSource {
  private static final int PERIOD_COUNT_UNSET = -1;
  private final MediaSource[] mediaSources;
+  private final Timeline.Window window;
  private int periodCount;
@@ -39,30 +40,26 @@ public final class MergingMediaSource implements MediaSource {
   */
  public MergingMediaSource(MediaSource... mediaSources) {
    this.mediaSources = mediaSources;
+    window = new Timeline.Window();
    periodCount = PERIOD_COUNT_UNSET;
  }
  @Override
  public void prepareSource(final Listener listener) {
    mediaSources[0].prepareSource(new Listener() {
      @Override
-      public void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+      public void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
        checkConsistentTimeline(timeline);
        // All source timelines must match.
        listener.onSourceInfoRefreshed(timeline, manifest);
      }
    });
    for (int i = 1; i < mediaSources.length; i++) {
      mediaSources[i].prepareSource(new Listener() {
        @Override
-        public void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+        public void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
          checkConsistentTimeline(timeline);
        }
      });
    }
  }
@@ -102,10 +99,10 @@ public final class MergingMediaSource implements MediaSource {
    }
  }
-  private void checkConsistentTimeline(MediaTimeline timeline) {
+  private void checkConsistentTimeline(Timeline timeline) {
    int windowCount = timeline.getWindowCount();
    for (int i = 0; i < windowCount; i++) {
-      Assertions.checkArgument(!timeline.getWindow(i).isDynamic);
+      Assertions.checkArgument(!timeline.getWindow(i, window, false).isDynamic);
    }
    int periodCount = timeline.getPeriodCount();
    if (this.periodCount == PERIOD_COUNT_UNSET) {

--- a/library/src/main/java/com/google/android/exoplayer2/source/SinglePeriodMediaTimeline.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/SinglePeriodMediaTimeline.java
-/*
- * Copyright (C) 2016 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 com.google.android.exoplayer2.source;
-import com.google.android.exoplayer2.C;
-import com.google.android.exoplayer2.MediaTimeline;
-import com.google.android.exoplayer2.MediaWindow;
-import com.google.android.exoplayer2.util.Assertions;
-/**
- * A {@link MediaTimeline} consisting of a single period and static window.
- */
-public final class SinglePeriodMediaTimeline implements MediaTimeline {
-  private static final Object ID = new Object();
-  private final long offsetInFirstPeriodUs;
-  private final MediaWindow window;
-  /**
-   * Creates a timeline with one period of known duration and a window extending from zero to its
-   * duration.
-   *
-   * @param durationUs The duration of the period, in microseconds.
-   * @param isSeekable Whether seeking is supported within the period.
-   */
-  public SinglePeriodMediaTimeline(long durationUs, boolean isSeekable) {
-    this(0, MediaWindow.createWindowFromZero(durationUs, isSeekable, false /* isDynamic */));
-  }
-  /**
-   * Creates a timeline with one period of known duration and a window extending from zero to its
-   * duration.
-   *
-   * @param offsetInFirstPeriodUs The offset of the start of the window in the period.
-   * @param window The available window within the period.
-   */
-  public SinglePeriodMediaTimeline(long offsetInFirstPeriodUs, MediaWindow window) {
-    this.offsetInFirstPeriodUs = offsetInFirstPeriodUs;
-    this.window = window;
-  }
-  @Override
-  public long getAbsoluteStartTime() {
-    return 0;
-  }
-  @Override
-  public int getPeriodCount() {
-    return 1;
-  }
-  @Override
-  public long getPeriodDurationMs(int periodIndex) {
-    return C.usToMs(getPeriodDurationUs(periodIndex));
-  }
-  @Override
-  public long getPeriodDurationUs(int periodIndex) {
-    Assertions.checkIndex(periodIndex, 0, 1);
-    return window.durationUs == C.TIME_UNSET ? C.TIME_UNSET
-        : (offsetInFirstPeriodUs + window.durationUs);
-  }
-  @Override
-  public Object getPeriodId(int periodIndex) {
-    Assertions.checkIndex(periodIndex, 0, 1);
-    return ID;
-  }
-  @Override
-  public MediaWindow getPeriodWindow(int periodIndex) {
-    Assertions.checkIndex(periodIndex, 0, 1);
-    return window;
-  }
-  @Override
-  public int getPeriodWindowIndex(int periodIndex) {
-    Assertions.checkIndex(periodIndex, 0, 1);
-    return 0;
-  }
-  @Override
-  public int getIndexOfPeriod(Object id) {
-    return ID.equals(id) ? 0 : C.INDEX_UNSET;
-  }
-  @Override
-  public int getWindowCount() {
-    return 1;
-  }
-  @Override
-  public MediaWindow getWindow(int windowIndex) {
-    Assertions.checkIndex(windowIndex, 0, 1);
-    return window;
-  }
-  @Override
-  public int getWindowFirstPeriodIndex(int windowIndex) {
-    Assertions.checkIndex(windowIndex, 0, 1);
-    return 0;
-  }
-  @Override
-  public int getWindowLastPeriodIndex(int windowIndex) {
-    Assertions.checkIndex(windowIndex, 0, 1);
-    return 0;
-  }
-  @Override
-  public long getWindowOffsetInFirstPeriodUs(int windowIndex) {
-    Assertions.checkIndex(windowIndex, 0, 1);
-    return offsetInFirstPeriodUs;
-  }
-}
--- a/library/src/main/java/com/google/android/exoplayer2/source/SinglePeriodTimeline.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/SinglePeriodTimeline.java
+/*
+ * Copyright (C) 2016 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 com.google.android.exoplayer2.source;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.Timeline;
+import com.google.android.exoplayer2.util.Assertions;
+/**
+ * A {@link Timeline} consisting of a single period and static window.
+ */
+public final class SinglePeriodTimeline extends Timeline {
+  private static final Object ID = new Object();
+  private final long periodDurationUs;
+  private final long windowDurationUs;
+  private final long windowPositionInPeriodUs;
+  private final long windowDefaultStartPositionUs;
+  private final boolean isSeekable;
+  private final boolean isDynamic;
+  /**
+   * Creates a timeline of one period of known duration, and a static window starting at zero and
+   * extending to that duration.
+   *
+   * @param durationUs The duration of the period, in microseconds.
+   * @param isSeekable Whether seeking is supported within the period.
+   */
+  public SinglePeriodTimeline(long durationUs, boolean isSeekable) {
+    this(durationUs, durationUs, 0, 0, isSeekable, false);
+  }
+  /**
+   * Creates a timeline with one period of known duration, and a window of known duration starting
+   * at a specified position in the period.
+   *
+   * @param periodDurationUs The duration of the period in microseconds.
+   * @param windowDurationUs The duration of the window in microseconds.
+   * @param windowPositionInPeriodUs The position of the start of the window in the period, in
+   *     microseconds.
+   * @param windowDefaultStartPositionUs The default position relative to the start of the window at
+   *     which to begin playback, in microseconds.
+   * @param isSeekable Whether seeking is supported within the window.
+   * @param isDynamic Whether the window may change when the timeline is updated.
+   */
+  public SinglePeriodTimeline(long periodDurationUs, long windowDurationUs,
+      long windowPositionInPeriodUs, long windowDefaultStartPositionUs, boolean isSeekable,
+      boolean isDynamic) {
+    this.periodDurationUs = periodDurationUs;
+    this.windowDurationUs = windowDurationUs;
+    this.windowPositionInPeriodUs = windowPositionInPeriodUs;
+    this.windowDefaultStartPositionUs = windowDefaultStartPositionUs;
+    this.isSeekable = isSeekable;
+    this.isDynamic = isDynamic;
+  }
+  @Override
+  public int getWindowCount() {
+    return 1;
+  }
+  @Override
+  public Window getWindow(int windowIndex, Window window, boolean setIds) {
+    Assertions.checkIndex(windowIndex, 0, 1);
+    Object id = setIds ? ID : null;
+    return window.set(id, C.TIME_UNSET, C.TIME_UNSET, isSeekable, isDynamic,
+        windowDefaultStartPositionUs, windowDurationUs, 0, 0, windowPositionInPeriodUs);
+  }
+  @Override
+  public int getPeriodCount() {
+    return 1;
+  }
+  @Override
+  public Period getPeriod(int periodIndex, Period period, boolean setIds) {
+    Assertions.checkIndex(periodIndex, 0, 1);
+    Object id = setIds ? ID : null;
+    return period.set(id, id, 0, periodDurationUs, -windowPositionInPeriodUs);
+  }
+  @Override
+  public int getIndexOfPeriod(Object uid) {
+    return ID.equals(uid) ? 0 : C.INDEX_UNSET;
+  }
+}
--- a/library/src/main/java/com/google/android/exoplayer2/source/SingleSampleMediaSource.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/SingleSampleMediaSource.java
@@ -18,7 +18,7 @@ package com.google.android.exoplayer2.source;
 import android.net.Uri;
 import android.os.Handler;
 import com.google.android.exoplayer2.Format;
-import com.google.android.exoplayer2.MediaTimeline;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.source.MediaPeriod.Callback;
 import com.google.android.exoplayer2.upstream.Allocator;
 import com.google.android.exoplayer2.upstream.DataSource;
@@ -57,7 +57,7 @@ public final class SingleSampleMediaSource implements MediaSource {
  private final Handler eventHandler;
  private final EventListener eventListener;
  private final int eventSourceId;
-  private final MediaTimeline timeline;
+  private final Timeline timeline;
  public SingleSampleMediaSource(Uri uri, DataSource.Factory dataSourceFactory, Format format,
      long durationUs) {
@@ -79,7 +79,7 @@ public final class SingleSampleMediaSource implements MediaSource {
    this.eventHandler = eventHandler;
    this.eventListener = eventListener;
    this.eventSourceId = eventSourceId;
-    timeline = new SinglePeriodMediaTimeline(durationUs, true);
+    timeline = new SinglePeriodTimeline(durationUs, true);
  }
  // MediaSource implementation.

--- a/library/src/main/java/com/google/android/exoplayer2/source/dash/DashMediaSource.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/dash/DashMediaSource.java
@@ -21,9 +21,8 @@ import android.os.SystemClock;
 import android.util.Log;
 import android.util.SparseArray;
 import com.google.android.exoplayer2.C;
-import com.google.android.exoplayer2.MediaTimeline;
-import com.google.android.exoplayer2.MediaWindow;
 import com.google.android.exoplayer2.ParserException;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.source.AdaptiveMediaSourceEventListener;
 import com.google.android.exoplayer2.source.AdaptiveMediaSourceEventListener.EventDispatcher;
 import com.google.android.exoplayer2.source.MediaPeriod;
@@ -71,8 +70,8 @@ public final class DashMediaSource implements MediaSource {
  public static final long DEFAULT_LIVE_EDGE_OFFSET_FIXED_MS = 30000;
  /**
   * The interval in milliseconds between invocations of
-   * {@link MediaSource.Listener#onSourceInfoRefreshed(MediaTimeline, Object)} when the source's
+   * {@link MediaSource.Listener#onSourceInfoRefreshed(Timeline, Object)} when the source's
-   * {@link MediaWindow} is changing dynamically (for example, for incomplete live streams).
+   * {@link Timeline} is changing dynamically (for example, for incomplete live streams).
   */
  private static final int NOTIFY_MANIFEST_INTERVAL_MS = 5000;
@@ -99,7 +98,6 @@ public final class DashMediaSource implements MediaSource {
  private long manifestLoadEndTimestamp;
  private DashManifest manifest;
  private Handler handler;
-  private MediaWindow window;
  private long elapsedRealtimeOffsetMs;
  private int firstPeriodId;
@@ -360,12 +358,12 @@ public final class DashMediaSource implements MediaSource {
    if (manifest.dynamic && !lastPeriodSeekInfo.isIndexExplicit) {
      // The manifest describes an incomplete live stream. Update the start/end times to reflect the
      // live stream duration and the manifest's time shift buffer depth.
-      long liveStreamDurationUs = getNowUnixTimeUs() - manifest.availabilityStartTime * 1000;
+      long liveStreamDurationUs = getNowUnixTimeUs() - C.msToUs(manifest.availabilityStartTime);
-      long liveStreamEndPositionInLastPeriodUs =
+      long liveStreamEndPositionInLastPeriodUs = liveStreamDurationUs
-          liveStreamDurationUs - manifest.getPeriod(lastPeriodIndex).startMs * 1000;
+          - C.msToUs(manifest.getPeriod(lastPeriodIndex).startMs);
      currentEndTimeUs = Math.min(liveStreamEndPositionInLastPeriodUs, currentEndTimeUs);
      if (manifest.timeShiftBufferDepth != C.TIME_UNSET) {
-        long timeShiftBufferDepthUs = manifest.timeShiftBufferDepth * 1000;
+        long timeShiftBufferDepthUs = C.msToUs(manifest.timeShiftBufferDepth);
        long offsetInPeriodUs = currentEndTimeUs - timeShiftBufferDepthUs;
        int periodIndex = lastPeriodIndex;
        while (offsetInPeriodUs < 0 && periodIndex > 0) {
@@ -386,7 +384,7 @@ public final class DashMediaSource implements MediaSource {
    for (int i = 0; i < manifest.getPeriodCount() - 1; i++) {
      windowDurationUs += manifest.getPeriodDurationUs(i);
    }
-    long defaultInitialTimeUs = 0;
+    long windowDefaultStartPositionUs = 0;
    if (manifest.dynamic) {
      long liveEdgeOffsetForManifestMs = liveEdgeOffsetMs;
      if (liveEdgeOffsetForManifestMs == DEFAULT_LIVE_EDGE_OFFSET_PREFER_MANIFEST_MS) {
@@ -395,7 +393,7 @@ public final class DashMediaSource implements MediaSource {
      }
      // Snap the default position to the start of the segment containing it.
      long initialTimeOffsetInWindowUs =
-          Math.max(0, windowDurationUs - (liveEdgeOffsetForManifestMs * 1000));
+          Math.max(0, windowDurationUs - C.msToUs(liveEdgeOffsetForManifestMs));
      int periodIndex = 0;
      long initialTimeOffsetInPeriodUs = currentStartTimeUs + initialTimeOffsetInWindowUs;
      long periodDurationUs = manifest.getPeriodDurationUs(periodIndex);
@@ -413,16 +411,18 @@ public final class DashMediaSource implements MediaSource {
        DashSegmentIndex index =
            period.adaptationSets.get(videoAdaptationSetIndex).representations.get(0).getIndex();
        int segmentNum = index.getSegmentNum(initialTimeOffsetInPeriodUs, periodDurationUs);
-        defaultInitialTimeUs =
+        windowDefaultStartPositionUs =
            initialTimeOffsetInWindowUs - initialTimeOffsetInPeriodUs + index.getTimeUs(segmentNum);
      } else {
-        defaultInitialTimeUs = initialTimeOffsetInWindowUs;
+        windowDefaultStartPositionUs = initialTimeOffsetInWindowUs;
      }
    }
-    window = new MediaWindow(windowDurationUs, true /* isSeekable */, manifest.dynamic,
+    long windowStartTimeMs = manifest.availabilityStartTime
-        defaultInitialTimeUs);
+        + manifest.getPeriod(0).startMs + C.usToMs(currentStartTimeUs);
-    sourceListener.onSourceInfoRefreshed(new DashMediaTimeline(firstPeriodId, currentStartTimeUs,
+    DashTimeline timeline = new DashTimeline(manifest.availabilityStartTime, windowStartTimeMs,
-        manifest, window), manifest);
+        firstPeriodId, currentStartTimeUs, windowDurationUs, windowDefaultStartPositionUs,
+        manifest);
+    sourceListener.onSourceInfoRefreshed(timeline, manifest);
  }
  private void scheduleManifestRefresh() {
@@ -450,9 +450,9 @@ public final class DashMediaSource implements MediaSource {
  private long getNowUnixTimeUs() {
    if (elapsedRealtimeOffsetMs != 0) {
-      return (SystemClock.elapsedRealtime() + elapsedRealtimeOffsetMs) * 1000;
+      return C.msToUs(SystemClock.elapsedRealtime() + elapsedRealtimeOffsetMs);
    } else {
-      return System.currentTimeMillis() * 1000;
+      return C.msToUs(System.currentTimeMillis());
    }
  }
@@ -462,7 +462,8 @@ public final class DashMediaSource implements MediaSource {
  private static final class PeriodSeekInfo {
-    public static PeriodSeekInfo createPeriodSeekInfo(Period period, long durationUs) {
+    public static PeriodSeekInfo createPeriodSeekInfo(
+        com.google.android.exoplayer2.source.dash.manifest.Period period, long durationUs) {
      int adaptationSetCount = period.adaptationSets.size();
      long availableStartTimeUs = 0;
      long availableEndTimeUs = Long.MAX_VALUE;
@@ -501,24 +502,27 @@ public final class DashMediaSource implements MediaSource {
  }
-  private static final class DashMediaTimeline implements MediaTimeline {
+  private static final class DashTimeline extends Timeline {
+    private final long presentationStartTimeMs;
+    private final long windowStartTimeMs;
    private final int firstPeriodId;
    private final long offsetInFirstPeriodUs;
+    private final long windowDurationUs;
+    private final long windowDefaultStartPositionUs;
    private final DashManifest manifest;
-    private final MediaWindow window;
-    public DashMediaTimeline(int firstPeriodId, long offsetInFirstPeriodUs, DashManifest manifest,
+    public DashTimeline(long presentationStartTimeMs, long windowStartTimeMs,
-        MediaWindow window) {
+        int firstPeriodId, long offsetInFirstPeriodUs, long windowDurationUs,
+        long windowDefaultStartPositionUs, DashManifest manifest) {
+      this.presentationStartTimeMs = presentationStartTimeMs;
+      this.windowStartTimeMs = windowStartTimeMs;
      this.firstPeriodId = firstPeriodId;
      this.offsetInFirstPeriodUs = offsetInFirstPeriodUs;
+      this.windowDurationUs = windowDurationUs;
+      this.windowDefaultStartPositionUs = windowDefaultStartPositionUs;
      this.manifest = manifest;
-      this.window = window;
-    }
-    @Override
-    public long getAbsoluteStartTime() {
-      return manifest.availabilityStartTime + manifest.getPeriod(0).startMs;
    }
    @Override
@@ -527,70 +531,39 @@ public final class DashMediaSource implements MediaSource {
    }
    @Override
-    public long getPeriodDurationMs(int periodIndex) {
+    public Period getPeriod(int periodIndex, Period period, boolean setIdentifiers) {
      Assertions.checkIndex(periodIndex, 0, manifest.getPeriodCount());
-      return manifest.getPeriodDurationMs(periodIndex);
+      Object id = setIdentifiers ? manifest.getPeriod(periodIndex).id : null;
+      Object uid = setIdentifiers ? firstPeriodId
+          + Assertions.checkIndex(periodIndex, 0, manifest.getPeriodCount()) : null;
+      return period.set(id, uid, 0, manifest.getPeriodDurationUs(periodIndex),
+          C.msToUs(manifest.getPeriod(periodIndex).startMs - manifest.getPeriod(0).startMs)
+              - offsetInFirstPeriodUs);
    }
    @Override
-    public long getPeriodDurationUs(int periodIndex) {
+    public int getWindowCount() {
-      Assertions.checkIndex(periodIndex, 0, manifest.getPeriodCount());
+      return 1;
-      return manifest.getPeriodDurationUs(periodIndex);
-    }
-    @Override
-    public Object getPeriodId(int periodIndex) {
-      return firstPeriodId + Assertions.checkIndex(periodIndex, 0, manifest.getPeriodCount());
-    }
-    @Override
-    public MediaWindow getPeriodWindow(int periodIndex) {
-      Assertions.checkIndex(periodIndex, 0, manifest.getPeriodCount());
-      return window;
    }
    @Override
-    public int getPeriodWindowIndex(int periodIndex) {
+    public Window getWindow(int windowIndex, Window window, boolean setIdentifier) {
-      Assertions.checkIndex(periodIndex, 0, manifest.getPeriodCount());
+      Assertions.checkIndex(windowIndex, 0, 1);
-      return 0;
+      return window.set(null, presentationStartTimeMs, windowStartTimeMs, true /* isSeekable */,
+          manifest.dynamic, windowDefaultStartPositionUs, windowDurationUs, 0,
+          manifest.getPeriodCount() - 1, offsetInFirstPeriodUs);
    }
    @Override
-    public int getIndexOfPeriod(Object id) {
+    public int getIndexOfPeriod(Object uid) {
-      if (!(id instanceof Integer)) {
+      if (!(uid instanceof Integer)) {
        return C.INDEX_UNSET;
      }
-      int periodId = (int) id;
+      int periodId = (int) uid;
      return periodId < firstPeriodId || periodId >= firstPeriodId + getPeriodCount()
          ? C.INDEX_UNSET : (periodId - firstPeriodId);
    }
-    @Override
-    public int getWindowCount() {
-      return 1;
-    }
-    @Override
-    public MediaWindow getWindow(int windowIndex) {
-      Assertions.checkIndex(windowIndex, 0, 1);
-      return window;
-    }
-    @Override
-    public int getWindowFirstPeriodIndex(int windowIndex) {
-      return 0;
-    }
-    @Override
-    public int getWindowLastPeriodIndex(int windowIndex) {
-      return manifest.getPeriodCount() - 1;
-    }
-    @Override
-    public long getWindowOffsetInFirstPeriodUs(int windowIndex) {
-      return offsetInFirstPeriodUs;
-    }
  }
  private final class ManifestCallback implements

--- a/library/src/main/java/com/google/android/exoplayer2/source/hls/HlsMediaPeriod.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/hls/HlsMediaPeriod.java
@@ -19,14 +19,14 @@ import android.net.Uri;
 import android.text.TextUtils;
 import com.google.android.exoplayer2.C;
 import com.google.android.exoplayer2.Format;
-import com.google.android.exoplayer2.MediaTimeline;
 import com.google.android.exoplayer2.ParserException;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.source.AdaptiveMediaSourceEventListener.EventDispatcher;
 import com.google.android.exoplayer2.source.CompositeSequenceableLoader;
 import com.google.android.exoplayer2.source.MediaPeriod;
 import com.google.android.exoplayer2.source.MediaSource;
 import com.google.android.exoplayer2.source.SampleStream;
-import com.google.android.exoplayer2.source.SinglePeriodMediaTimeline;
+import com.google.android.exoplayer2.source.SinglePeriodTimeline;
 import com.google.android.exoplayer2.source.TrackGroup;
 import com.google.android.exoplayer2.source.TrackGroupArray;
 import com.google.android.exoplayer2.source.hls.playlist.HlsMasterPlaylist;
@@ -282,7 +282,7 @@ import java.util.List;
    callback.onPrepared(this);
    // TODO[playlists]: Calculate the window.
-    MediaTimeline timeline = new SinglePeriodMediaTimeline(durationUs, !isLive);
+    Timeline timeline = new SinglePeriodTimeline(durationUs, !isLive);
    sourceListener.onSourceInfoRefreshed(timeline, playlist);
  }

--- a/library/src/main/java/com/google/android/exoplayer2/source/hls/HlsMediaSource.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/hls/HlsMediaSource.java
@@ -23,7 +23,7 @@ import com.google.android.exoplayer2.source.AdaptiveMediaSourceEventListener.Eve
 import com.google.android.exoplayer2.source.MediaPeriod;
 import com.google.android.exoplayer2.source.MediaPeriod.Callback;
 import com.google.android.exoplayer2.source.MediaSource;
-import com.google.android.exoplayer2.source.SinglePeriodMediaTimeline;
+import com.google.android.exoplayer2.source.SinglePeriodTimeline;
 import com.google.android.exoplayer2.upstream.Allocator;
 import com.google.android.exoplayer2.upstream.DataSource;
 import com.google.android.exoplayer2.util.Assertions;
@@ -64,7 +64,7 @@ public final class HlsMediaSource implements MediaSource {
  public void prepareSource(MediaSource.Listener listener) {
    sourceListener = listener;
    // TODO: Defer until the playlist has been loaded.
-    listener.onSourceInfoRefreshed(new SinglePeriodMediaTimeline(C.TIME_UNSET, false), null);
+    listener.onSourceInfoRefreshed(new SinglePeriodTimeline(C.TIME_UNSET, false), null);
  }
  @Override

--- a/library/src/main/java/com/google/android/exoplayer2/source/smoothstreaming/SsMediaSource.java
+++ b/library/src/main/java/com/google/android/exoplayer2/source/smoothstreaming/SsMediaSource.java
@@ -19,15 +19,14 @@ import android.net.Uri;
 import android.os.Handler;
 import android.os.SystemClock;
 import com.google.android.exoplayer2.C;
-import com.google.android.exoplayer2.MediaTimeline;
-import com.google.android.exoplayer2.MediaWindow;
 import com.google.android.exoplayer2.ParserException;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.source.AdaptiveMediaSourceEventListener;
 import com.google.android.exoplayer2.source.AdaptiveMediaSourceEventListener.EventDispatcher;
 import com.google.android.exoplayer2.source.MediaPeriod;
 import com.google.android.exoplayer2.source.MediaPeriod.Callback;
 import com.google.android.exoplayer2.source.MediaSource;
-import com.google.android.exoplayer2.source.SinglePeriodMediaTimeline;
+import com.google.android.exoplayer2.source.SinglePeriodTimeline;
 import com.google.android.exoplayer2.source.smoothstreaming.manifest.SsManifest;
 import com.google.android.exoplayer2.source.smoothstreaming.manifest.SsManifest.StreamElement;
 import com.google.android.exoplayer2.source.smoothstreaming.manifest.SsManifestParser;
@@ -157,7 +156,7 @@ public final class SsMediaSource implements MediaSource,
    for (int i = 0; i < mediaPeriods.size(); i++) {
      mediaPeriods.get(i).updateManifest(manifest);
    }
-    MediaTimeline timeline;
+    Timeline timeline;
    if (manifest.isLive) {
      long startTimeUs = Long.MAX_VALUE;
      long endTimeUs = Long.MIN_VALUE;
@@ -170,21 +169,20 @@ public final class SsMediaSource implements MediaSource,
        }
      }
      if (startTimeUs == Long.MAX_VALUE) {
-        timeline = new SinglePeriodMediaTimeline(C.TIME_UNSET, false);
+        timeline = new SinglePeriodTimeline(C.TIME_UNSET, false);
      } else {
        if (manifest.dvrWindowLengthUs != C.TIME_UNSET
            && manifest.dvrWindowLengthUs > 0) {
          startTimeUs = Math.max(startTimeUs, endTimeUs - manifest.dvrWindowLengthUs);
        }
        long durationUs = endTimeUs - startTimeUs;
-        long defaultInitialStartPositionUs = Math.max(0, durationUs - (liveEdgeOffsetMs * 1000));
+        long defaultStartPositionUs = Math.max(0, durationUs - (liveEdgeOffsetMs * 1000));
-        MediaWindow window = new MediaWindow(durationUs, true /* isSeekable */,
+        timeline = new SinglePeriodTimeline(C.TIME_UNSET, durationUs, startTimeUs,
-            true /* isDynamic */, defaultInitialStartPositionUs);
+            defaultStartPositionUs, true /* isSeekable */, true /* isDynamic */);
-        timeline = new SinglePeriodMediaTimeline(startTimeUs, window);
      }
    } else {
      boolean isSeekable = manifest.durationUs != C.TIME_UNSET;
-      timeline = new SinglePeriodMediaTimeline(manifest.durationUs, isSeekable);
+      timeline = new SinglePeriodTimeline(manifest.durationUs, isSeekable);
    }
    sourceListener.onSourceInfoRefreshed(timeline, manifest);
    scheduleManifestRefresh();

--- a/library/src/main/java/com/google/android/exoplayer2/ui/DebugTextViewHelper.java
+++ b/library/src/main/java/com/google/android/exoplayer2/ui/DebugTextViewHelper.java
@@ -19,8 +19,8 @@ import android.widget.TextView;
 import com.google.android.exoplayer2.ExoPlaybackException;
 import com.google.android.exoplayer2.ExoPlayer;
 import com.google.android.exoplayer2.Format;
-import com.google.android.exoplayer2.MediaTimeline;
 import com.google.android.exoplayer2.SimpleExoPlayer;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.decoder.DecoderCounters;
 /**
@@ -89,7 +89,7 @@ public final class DebugTextViewHelper implements Runnable, ExoPlayer.EventListe
  }
  @Override
-  public void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+  public void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
    // Do nothing.
  }

--- a/library/src/main/java/com/google/android/exoplayer2/ui/MediaControllerPrevNextClickListener.java
+++ b/library/src/main/java/com/google/android/exoplayer2/ui/MediaControllerPrevNextClickListener.java
@@ -17,15 +17,14 @@ package com.google.android.exoplayer2.ui;
 import android.view.View;
 import android.view.View.OnClickListener;
-import com.google.android.exoplayer2.C;
 import com.google.android.exoplayer2.ExoPlayer;
-import com.google.android.exoplayer2.MediaTimeline;
+import com.google.android.exoplayer2.Timeline;
 /**
 * An {@link OnClickListener} that can be passed to
 * {@link android.widget.MediaController#setPrevNextListeners(OnClickListener, OnClickListener)} to
 * make the controller's previous and next buttons seek to the previous and next windows in the
- * {@link MediaTimeline}.
+ * {@link Timeline}.
 */
 public class MediaControllerPrevNextClickListener implements OnClickListener {
@@ -50,15 +49,15 @@ public class MediaControllerPrevNextClickListener implements OnClickListener {
  @Override
  public void onClick(View v) {
-    int currentWindowIndex = player.getCurrentWindowIndex();
+    Timeline timeline = player.getCurrentTimeline();
-    if (currentWindowIndex == C.INDEX_UNSET) {
+    if (timeline == null) {
      return;
    }
-    MediaTimeline timeline = player.getCurrentTimeline();
+    int currentWindowIndex = player.getCurrentWindowIndex();
    if (isNext) {
      if (currentWindowIndex < timeline.getWindowCount() - 1) {
        player.seekToDefaultPosition(currentWindowIndex + 1);
-      } else if (timeline.getWindow(currentWindowIndex).isDynamic) {
+      } else if (timeline.getWindow(currentWindowIndex, new Timeline.Window(), false).isDynamic) {
        // Seek to the live edge.
        player.seekToDefaultPosition();
      }
@@ -67,7 +66,7 @@ public class MediaControllerPrevNextClickListener implements OnClickListener {
          && player.getCurrentPosition() <= MAX_POSITION_FOR_SEEK_TO_PREVIOUS) {
        player.seekToDefaultPosition(currentWindowIndex - 1);
      } else {
-        player.seekTo(currentWindowIndex, 0);
+        player.seekTo(0);
      }
    }
  }

--- a/playbacktests/src/main/java/com/google/android/exoplayer2/playbacktests/util/ExoHostedTest.java
+++ b/playbacktests/src/main/java/com/google/android/exoplayer2/playbacktests/util/ExoHostedTest.java
@@ -24,8 +24,8 @@ import com.google.android.exoplayer2.ExoPlaybackException;
 import com.google.android.exoplayer2.ExoPlayer;
 import com.google.android.exoplayer2.ExoPlayerFactory;
 import com.google.android.exoplayer2.Format;
-import com.google.android.exoplayer2.MediaTimeline;
 import com.google.android.exoplayer2.SimpleExoPlayer;
+import com.google.android.exoplayer2.Timeline;
 import com.google.android.exoplayer2.audio.AudioRendererEventListener;
 import com.google.android.exoplayer2.audio.AudioTrack;
 import com.google.android.exoplayer2.decoder.DecoderCounters;
@@ -215,7 +215,7 @@ public abstract class ExoHostedTest implements HostedTest, ExoPlayer.EventListen
  }
  @Override
-  public final void onSourceInfoRefreshed(MediaTimeline timeline, Object manifest) {
+  public final void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
    // Do nothing.
  }