Remove V1 DASH multi-period + seeking-in-window from V2.

Both of these features are being promoted to first class
citizens in V2 (multi-period support will be handled via
playlists, seeking-in-window will be handled by exposing
the window/timeline from the player and via the normal
seek API). For now, it's much easier to continue the
refactoring process with the features removed.
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=119518675

demo/src/main/java/com/google/android/exoplayer/demo/EventLogger.java

@@ -19,7 +19,6 @@ import com.google.android.exoplayer.DefaultTrackSelector.TrackInfo;
 import com.google.android.exoplayer.ExoPlayer;
 import com.google.android.exoplayer.Format;
 import com.google.android.exoplayer.MediaCodecTrackRenderer.DecoderInitializationException;
-import com.google.android.exoplayer.TimeRange;
 import com.google.android.exoplayer.TrackGroup;
 import com.google.android.exoplayer.TrackGroupArray;
 import com.google.android.exoplayer.TrackRenderer;
@@ -50,7 +49,6 @@ public class EventLogger implements DemoPlayer.Listener, DemoPlayer.InfoListener
   }
 
   private long sessionStartTimeMs;
-  private long[] availableRangeValuesUs;
 
   public void startSession() {
     sessionStartTimeMs = SystemClock.elapsedRealtime();
@@ -215,13 +213,6 @@ public class EventLogger implements DemoPlayer.Listener, DemoPlayer.InfoListener
     Log.d(TAG, "decoderInitialized [" + getSessionTimeString() + ", " + decoderName + "]");
   }
 
-  @Override
-  public void onAvailableRangeChanged(int sourceId, TimeRange availableRange) {
-    availableRangeValuesUs = availableRange.getCurrentBoundsUs(availableRangeValuesUs);
-    Log.d(TAG, "availableRange [" + availableRange.isStatic() + ", " + availableRangeValuesUs[0]
-        + ", " + availableRangeValuesUs[1] + "]");
-  }
-
   private void printInternalError(String type, Exception e) {
     Log.e(TAG, "internalError [" + getSessionTimeString() + ", " + type + "]", e);
   }

demo/src/main/java/com/google/android/exoplayer/demo/player/DashSourceBuilder.java

@@ -44,8 +44,6 @@ import android.os.Handler;
 // TODO[REFACTOR]: Bring back UTC timing element support.
 public class DashSourceBuilder implements SourceBuilder {
 
-  private static final String TAG = "DashSourceBuilder";
-
   private static final int BUFFER_SEGMENT_SIZE = 64 * 1024;
   private static final int VIDEO_BUFFER_SEGMENTS = 200;
   private static final int AUDIO_BUFFER_SEGMENTS = 54;
@@ -78,15 +76,14 @@ public class DashSourceBuilder implements SourceBuilder {
     // Build the video renderer.
     DataSource videoDataSource = dataSourceFactory.createDataSource(bandwidthMeter);
     ChunkSource videoChunkSource = new DashChunkSource(manifestFetcher, AdaptationSet.TYPE_VIDEO,
-        videoDataSource, new AdaptiveEvaluator(bandwidthMeter), LIVE_EDGE_LATENCY_MS,
+        videoDataSource, new AdaptiveEvaluator(bandwidthMeter), LIVE_EDGE_LATENCY_MS);
-        0, mainHandler, player, DemoPlayer.TYPE_VIDEO);
     ChunkSampleSource videoSampleSource = new ChunkSampleSource(videoChunkSource, loadControl,
         VIDEO_BUFFER_SEGMENTS * BUFFER_SEGMENT_SIZE, mainHandler, player, DemoPlayer.TYPE_VIDEO);
 
     // Build the audio renderer.
     DataSource audioDataSource = dataSourceFactory.createDataSource(bandwidthMeter);
     ChunkSource audioChunkSource = new DashChunkSource(manifestFetcher, AdaptationSet.TYPE_AUDIO,
-        audioDataSource, null, LIVE_EDGE_LATENCY_MS, 0, mainHandler, player, DemoPlayer.TYPE_AUDIO);
+        audioDataSource, null, LIVE_EDGE_LATENCY_MS);
     ChunkSampleSource audioSampleSource = new ChunkSampleSource(audioChunkSource, loadControl,
         AUDIO_BUFFER_SEGMENTS * BUFFER_SEGMENT_SIZE, mainHandler, player,
         DemoPlayer.TYPE_AUDIO);
@@ -94,7 +91,7 @@ public class DashSourceBuilder implements SourceBuilder {
     // Build the text renderer.
     DataSource textDataSource = dataSourceFactory.createDataSource(bandwidthMeter);
     ChunkSource textChunkSource = new DashChunkSource(manifestFetcher, AdaptationSet.TYPE_TEXT,
-        textDataSource, null, LIVE_EDGE_LATENCY_MS, 0, mainHandler, player, DemoPlayer.TYPE_TEXT);
+        textDataSource, null, LIVE_EDGE_LATENCY_MS);
     ChunkSampleSource textSampleSource = new ChunkSampleSource(textChunkSource, loadControl,
         TEXT_BUFFER_SEGMENTS * BUFFER_SEGMENT_SIZE, mainHandler, player,
         DemoPlayer.TYPE_TEXT);

demo/src/main/java/com/google/android/exoplayer/demo/player/DemoPlayer.java

@@ -27,12 +27,10 @@ import com.google.android.exoplayer.MediaCodecTrackRenderer.DecoderInitializatio
 import com.google.android.exoplayer.MediaCodecVideoTrackRenderer;
 import com.google.android.exoplayer.SampleSource;
 import com.google.android.exoplayer.SingleSampleSource;
-import com.google.android.exoplayer.TimeRange;
 import com.google.android.exoplayer.TrackRenderer;
 import com.google.android.exoplayer.audio.AudioCapabilities;
 import com.google.android.exoplayer.audio.AudioTrack;
 import com.google.android.exoplayer.chunk.ChunkSampleSourceEventListener;
-import com.google.android.exoplayer.dash.DashChunkSource;
 import com.google.android.exoplayer.drm.StreamingDrmSessionManager;
 import com.google.android.exoplayer.extractor.ExtractorSampleSource;
 import com.google.android.exoplayer.metadata.MetadataTrackRenderer;
@@ -67,8 +65,8 @@ public class DemoPlayer implements ExoPlayer.Listener, DefaultTrackSelector.Even
     ChunkSampleSourceEventListener, ExtractorSampleSource.EventListener,
     SingleSampleSource.EventListener, DefaultBandwidthMeter.EventListener,
     MediaCodecVideoTrackRenderer.EventListener, MediaCodecAudioTrackRenderer.EventListener,
-    StreamingDrmSessionManager.EventListener, DashChunkSource.EventListener, TextRenderer,
+    StreamingDrmSessionManager.EventListener, TextRenderer, MetadataRenderer<List<Id3Frame>>,
-    MetadataRenderer<List<Id3Frame>>, DebugTextViewHelper.Provider {
+    DebugTextViewHelper.Provider {
 
   /**
    * Builds a source to play.
@@ -127,7 +125,6 @@ public class DemoPlayer implements ExoPlayer.Listener, DefaultTrackSelector.Even
         long mediaStartTimeMs, long mediaEndTimeMs, long elapsedRealtimeMs, long loadDurationMs);
     void onDecoderInitialized(String decoderName, long elapsedRealtimeMs,
         long initializationDurationMs);
-    void onAvailableRangeChanged(int sourceId, TimeRange availableRange);
   }
 
   /**
@@ -441,13 +438,6 @@ public class DemoPlayer implements ExoPlayer.Listener, DefaultTrackSelector.Even
     }
   }
 
-  @Override
-  public void onAvailableRangeChanged(int sourceId, TimeRange availableRange) {
-    if (infoListener != null) {
-      infoListener.onAvailableRangeChanged(sourceId, availableRange);
-    }
-  }
-
   @Override
   public void onPlayWhenReadyCommitted() {
     // Do nothing.

library/src/androidTest/java/com/google/android/exoplayer/TimeRangeTest.java

@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2014 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.exoplayer;
-
-import com.google.android.exoplayer.TimeRange.StaticTimeRange;
-
-import junit.framework.TestCase;
-
-/**
- * Unit test for {@link TimeRange}.
- */
-public class TimeRangeTest extends TestCase {
-
-  public void testStaticEquals() {
-    TimeRange timeRange1 = new StaticTimeRange(0, 30000000);
-    assertTrue(timeRange1.equals(timeRange1));
-
-    TimeRange timeRange2 = new StaticTimeRange(0, 30000000);
-    assertTrue(timeRange1.equals(timeRange2));
-
-    TimeRange timeRange3 = new StaticTimeRange(0, 60000000);
-    assertFalse(timeRange1.equals(timeRange3));
-  }
-
-}

library/src/main/java/com/google/android/exoplayer/TimeRange.java

@@ -1,203 +0,0 @@
-/*
- * Copyright (C) 2014 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.exoplayer;
-
-import com.google.android.exoplayer.util.Clock;
-
-import android.os.SystemClock;
-
-/**
- * A container to store a start and end time in microseconds.
- */
-public interface TimeRange {
-
-  /**
-   * Whether the range is static, meaning repeated calls to {@link #getCurrentBoundsMs(long[])}
-   * or {@link #getCurrentBoundsUs(long[])} will return identical results.
-   *
-   * @return Whether the range is static.
-   */
-  public boolean isStatic();
-
-  /**
-   * Returns the start and end times (in milliseconds) of the TimeRange in the provided array,
-   * or creates a new one.
-   *
-   * @param out An array to store the start and end times; can be null.
-   * @return An array containing the start time (index 0) and end time (index 1) in milliseconds.
-   */
-  public long[] getCurrentBoundsMs(long[] out);
-
-  /**
-   * Returns the start and end times (in microseconds) of the TimeRange in the provided array,
-   * or creates a new one.
-   *
-   * @param out An array to store the start and end times; can be null.
-   * @return An array containing the start time (index 0) and end time (index 1) in microseconds.
-   */
-  public long[] getCurrentBoundsUs(long[] out);
-
-  /**
-   * A static {@link TimeRange}.
-   */
-  public static final class StaticTimeRange implements TimeRange {
-
-    private final long startTimeUs;
-    private final long endTimeUs;
-
-    /**
-     * @param startTimeUs The beginning of the range.
-     * @param endTimeUs The end of the range.
-     */
-    public StaticTimeRange(long startTimeUs, long endTimeUs) {
-      this.startTimeUs = startTimeUs;
-      this.endTimeUs = endTimeUs;
-    }
-
-    @Override
-    public boolean isStatic() {
-      return true;
-    }
-
-    @Override
-    public long[] getCurrentBoundsMs(long[] out) {
-      out = getCurrentBoundsUs(out);
-      out[0] /= 1000;
-      out[1] /= 1000;
-      return out;
-    }
-
-    @Override
-    public long[] getCurrentBoundsUs(long[] out) {
-      if (out == null || out.length < 2) {
-        out = new long[2];
-      }
-      out[0] = startTimeUs;
-      out[1] = endTimeUs;
-      return out;
-    }
-
-    @Override
-    public int hashCode() {
-      int result = 17;
-      result = 31 * result + (int) startTimeUs;
-      result = 31 * result + (int) endTimeUs;
-      return result;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-      if (obj == this) {
-        return true;
-      }
-      if (obj == null || getClass() != obj.getClass()) {
-        return false;
-      }
-      StaticTimeRange other = (StaticTimeRange) obj;
-      return other.startTimeUs == startTimeUs
-          && other.endTimeUs == endTimeUs;
-    }
-
-  }
-
-  /**
-   * A dynamic {@link TimeRange}.
-   */
-  public static final class DynamicTimeRange implements TimeRange {
-
-    private final long minStartTimeUs;
-    private final long maxEndTimeUs;
-    private final long elapsedRealtimeAtStartUs;
-    private final long bufferDepthUs;
-    private final Clock systemClock;
-
-    /**
-     * @param minStartTimeUs A lower bound on the beginning of the range.
-     * @param maxEndTimeUs An upper bound on the end of the range.
-     * @param elapsedRealtimeAtStartUs The value of {@link SystemClock#elapsedRealtime()},
-     *     multiplied by 1000, corresponding to a media time of zero.
-     * @param bufferDepthUs The buffer depth of the media, or -1.
-     * @param systemClock A system clock.
-     */
-    public DynamicTimeRange(long minStartTimeUs, long maxEndTimeUs, long elapsedRealtimeAtStartUs,
-        long bufferDepthUs, Clock systemClock) {
-      this.minStartTimeUs = minStartTimeUs;
-      this.maxEndTimeUs = maxEndTimeUs;
-      this.elapsedRealtimeAtStartUs = elapsedRealtimeAtStartUs;
-      this.bufferDepthUs = bufferDepthUs;
-      this.systemClock = systemClock;
-    }
-
-    @Override
-    public boolean isStatic() {
-      return false;
-    }
-
-    @Override
-    public long[] getCurrentBoundsMs(long[] out) {
-      out = getCurrentBoundsUs(out);
-      out[0] /= 1000;
-      out[1] /= 1000;
-      return out;
-    }
-
-    @Override
-    public long[] getCurrentBoundsUs(long[] out) {
-      if (out == null || out.length < 2) {
-        out = new long[2];
-      }
-      // Don't allow the end time to be greater than the total elapsed time.
-      long currentEndTimeUs = Math.min(maxEndTimeUs,
-          (systemClock.elapsedRealtime() * 1000) - elapsedRealtimeAtStartUs);
-      long currentStartTimeUs = minStartTimeUs;
-      if (bufferDepthUs != -1) {
-        // Don't allow the start time to be less than the current end time minus the buffer depth.
-        currentStartTimeUs = Math.max(currentStartTimeUs,
-            currentEndTimeUs - bufferDepthUs);
-      }
-      out[0] = currentStartTimeUs;
-      out[1] = currentEndTimeUs;
-      return out;
-    }
-
-    @Override
-    public int hashCode() {
-      int result = 17;
-      result = 31 * result + (int) minStartTimeUs;
-      result = 31 * result + (int) maxEndTimeUs;
-      result = 31 * result + (int) elapsedRealtimeAtStartUs;
-      result = 31 * result + (int) bufferDepthUs;
-      return result;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-      if (obj == this) {
-        return true;
-      }
-      if (obj == null || getClass() != obj.getClass()) {
-        return false;
-      }
-      DynamicTimeRange other = (DynamicTimeRange) obj;
-      return other.minStartTimeUs == minStartTimeUs
-          && other.maxEndTimeUs == maxEndTimeUs
-          && other.elapsedRealtimeAtStartUs == elapsedRealtimeAtStartUs
-          && other.bufferDepthUs == bufferDepthUs;
-    }
-
-  }
-
-}

library/src/main/java/com/google/android/exoplayer/chunk/BaseMediaChunk.java

@@ -50,11 +50,10 @@ public abstract class BaseMediaChunk extends MediaChunk {
    *     be called at any time to obtain the sample format and drm initialization data. False if
    *     these methods are only guaranteed to return correct data after the first sample data has
    *     been output from the chunk.
-   * @param parentId Identifier for a parent from which this chunk originates.
    */
   public BaseMediaChunk(DataSource dataSource, DataSpec dataSpec, int trigger, Format format,
-      long startTimeUs, long endTimeUs, int chunkIndex, boolean isSampleFormatFinal, int parentId) {
+      long startTimeUs, long endTimeUs, int chunkIndex, boolean isSampleFormatFinal) {
-    super(dataSource, dataSpec, trigger, format, startTimeUs, endTimeUs, chunkIndex, parentId);
+    super(dataSource, dataSpec, trigger, format, startTimeUs, endTimeUs, chunkIndex);
     this.isSampleFormatFinal = isSampleFormatFinal;
   }
 

library/src/main/java/com/google/android/exoplayer/chunk/Chunk.java

@@ -76,10 +76,6 @@ public abstract class Chunk implements Loadable {
    * Implementations may define custom {@link #trigger} codes greater than or equal to this value.
    */
   public static final int TRIGGER_CUSTOM_BASE = 10000;
-  /**
-   * Value of {@link #parentId} if no parent id need be specified.
-   */
-  public static final int NO_PARENT_ID = -1;
 
   /**
    * The type of the chunk. For reporting only.
@@ -98,10 +94,6 @@ public abstract class Chunk implements Loadable {
    * The {@link DataSpec} that defines the data to be loaded.
    */
   public final DataSpec dataSpec;
-  /**
-   * Optional identifier for a parent from which this chunk originates.
-   */
-  public final int parentId;
 
   protected final DataSource dataSource;
 
@@ -114,16 +106,13 @@ public abstract class Chunk implements Loadable {
    * @param type See {@link #type}.
    * @param trigger See {@link #trigger}.
    * @param format See {@link #format}.
-   * @param parentId See {@link #parentId}.
    */
-  public Chunk(DataSource dataSource, DataSpec dataSpec, int type, int trigger, Format format,
+  public Chunk(DataSource dataSource, DataSpec dataSpec, int type, int trigger, Format format) {
-      int parentId) {
     this.dataSource = Assertions.checkNotNull(dataSource);
     this.dataSpec = Assertions.checkNotNull(dataSpec);
     this.type = type;
     this.trigger = trigger;
     this.format = format;
-    this.parentId = parentId;
   }
 
   /**

library/src/main/java/com/google/android/exoplayer/chunk/ContainerMediaChunk.java

@@ -60,14 +60,13 @@ public class ContainerMediaChunk extends BaseMediaChunk implements SingleTrackOu
    * @param isSampleFormatFinal True if {@code sampleFormat} and {@code drmInitData} are known to be
    *     correct and final. False if the data may define its own sample format or initialization
    *     data.
-   * @param parentId Identifier for a parent from which this chunk originates.
    */
   public ContainerMediaChunk(DataSource dataSource, DataSpec dataSpec, int trigger, Format format,
       long startTimeUs, long endTimeUs, int chunkIndex, long sampleOffsetUs,
       ChunkExtractorWrapper extractorWrapper, Format sampleFormat, DrmInitData drmInitData,
-      boolean isSampleFormatFinal, int parentId) {
+      boolean isSampleFormatFinal) {
     super(dataSource, dataSpec, trigger, format, startTimeUs, endTimeUs, chunkIndex,
-        isSampleFormatFinal, parentId);
+        isSampleFormatFinal);
     this.extractorWrapper = extractorWrapper;
     this.sampleOffsetUs = sampleOffsetUs;
     this.sampleFormat = getAdjustedSampleFormat(sampleFormat, sampleOffsetUs);

library/src/main/java/com/google/android/exoplayer/chunk/DataChunk.java

@@ -44,12 +44,11 @@ public abstract class DataChunk extends Chunk {
    * @param type See {@link #type}.
    * @param trigger See {@link #trigger}.
    * @param format See {@link #format}.
-   * @param parentId Identifier for a parent from which this chunk originates.
    * @param data An optional recycled array that can be used as a holder for the data.
    */
   public DataChunk(DataSource dataSource, DataSpec dataSpec, int type, int trigger, Format format,
-      int parentId, byte[] data) {
+      byte[] data) {
-    super(dataSource, dataSpec, type, trigger, format, parentId);
+    super(dataSource, dataSpec, type, trigger, format);
     this.data = data;
   }
 

library/src/main/java/com/google/android/exoplayer/chunk/InitializationChunk.java

@@ -46,11 +46,6 @@ public final class InitializationChunk extends Chunk implements SingleTrackOutpu
   private volatile int bytesLoaded;
   private volatile boolean loadCanceled;
 
-  public InitializationChunk(DataSource dataSource, DataSpec dataSpec, int trigger, Format format,
-      ChunkExtractorWrapper extractorWrapper) {
-    this(dataSource, dataSpec, trigger, format, extractorWrapper, Chunk.NO_PARENT_ID);
-  }
-
   /**
    * Constructor for a chunk of media samples.
    *
@@ -59,11 +54,10 @@ public final class InitializationChunk extends Chunk implements SingleTrackOutpu
    * @param trigger The reason for this chunk being selected.
    * @param format The format of the stream to which this chunk belongs.
    * @param extractorWrapper A wrapped extractor to use for parsing the initialization data.
-   * @param parentId Identifier for a parent from which this chunk originates.
    */
   public InitializationChunk(DataSource dataSource, DataSpec dataSpec, int trigger, Format format,
-      ChunkExtractorWrapper extractorWrapper, int parentId) {
+      ChunkExtractorWrapper extractorWrapper) {
-    super(dataSource, dataSpec, Chunk.TYPE_MEDIA_INITIALIZATION, trigger, format, parentId);
+    super(dataSource, dataSpec, Chunk.TYPE_MEDIA_INITIALIZATION, trigger, format);
     this.extractorWrapper = extractorWrapper;
   }
 

library/src/main/java/com/google/android/exoplayer/chunk/MediaChunk.java

@@ -38,16 +38,6 @@ public abstract class MediaChunk extends Chunk {
    */
   public final int chunkIndex;
 
-  public MediaChunk(DataSource dataSource, DataSpec dataSpec, int trigger, Format format,
-      long startTimeUs, long endTimeUs, int chunkIndex) {
-    this(dataSource, dataSpec, trigger, format, startTimeUs, endTimeUs, chunkIndex,
-        Chunk.NO_PARENT_ID);
-  }
-
-  public int getNextChunkIndex() {
-    return chunkIndex + 1;
-  }
-
   /**
    * @param dataSource A {@link DataSource} for loading the data.
    * @param dataSpec Defines the data to be loaded.
@@ -56,15 +46,18 @@ public abstract class MediaChunk extends Chunk {
    * @param startTimeUs The start time of the media contained by the chunk, in microseconds.
    * @param endTimeUs The end time of the media contained by the chunk, in microseconds.
    * @param chunkIndex The index of the chunk.
-   * @param parentId Identifier for a parent from which this chunk originates.
    */
   public MediaChunk(DataSource dataSource, DataSpec dataSpec, int trigger, Format format,
-      long startTimeUs, long endTimeUs, int chunkIndex, int parentId) {
+      long startTimeUs, long endTimeUs, int chunkIndex) {
-    super(dataSource, dataSpec, Chunk.TYPE_MEDIA, trigger, format, parentId);
+    super(dataSource, dataSpec, Chunk.TYPE_MEDIA, trigger, format);
     Assertions.checkNotNull(format);
     this.startTimeUs = startTimeUs;
     this.endTimeUs = endTimeUs;
     this.chunkIndex = chunkIndex;
   }
 
+  public final int getNextChunkIndex() {
+    return chunkIndex + 1;
+  }
+
 }

library/src/main/java/com/google/android/exoplayer/chunk/SingleSampleMediaChunk.java

@@ -48,13 +48,11 @@ public final class SingleSampleMediaChunk extends BaseMediaChunk {
    * @param sampleFormat The format of the sample.
    * @param sampleDrmInitData The {@link DrmInitData} for the sample. Null if the sample is not drm
    *     protected.
-   * @param parentId Identifier for a parent from which this chunk originates.
    */
   public SingleSampleMediaChunk(DataSource dataSource, DataSpec dataSpec, int trigger,
       Format format, long startTimeUs, long endTimeUs, int chunkIndex, Format sampleFormat,
-      DrmInitData sampleDrmInitData, int parentId) {
+      DrmInitData sampleDrmInitData) {
-    super(dataSource, dataSpec, trigger, format, startTimeUs, endTimeUs, chunkIndex, true,
+    super(dataSource, dataSpec, trigger, format, startTimeUs, endTimeUs, chunkIndex, true);
-        parentId);
     this.sampleFormat = sampleFormat;
     this.sampleDrmInitData = sampleDrmInitData;
   }

library/src/main/java/com/google/android/exoplayer/dash/DashChunkSource.java

@@ -19,9 +19,6 @@ import com.google.android.exoplayer.BehindLiveWindowException;
 import com.google.android.exoplayer.C;
 import com.google.android.exoplayer.Format;
 import com.google.android.exoplayer.Format.DecreasingBandwidthComparator;
-import com.google.android.exoplayer.TimeRange;
-import com.google.android.exoplayer.TimeRange.DynamicTimeRange;
-import com.google.android.exoplayer.TimeRange.StaticTimeRange;
 import com.google.android.exoplayer.TrackGroup;
 import com.google.android.exoplayer.chunk.Chunk;
 import com.google.android.exoplayer.chunk.ChunkExtractorWrapper;
@@ -45,13 +42,8 @@ import com.google.android.exoplayer.extractor.mkv.MatroskaExtractor;
 import com.google.android.exoplayer.extractor.mp4.FragmentedMp4Extractor;
 import com.google.android.exoplayer.upstream.DataSource;
 import com.google.android.exoplayer.upstream.DataSpec;
-import com.google.android.exoplayer.util.Clock;
 import com.google.android.exoplayer.util.ManifestFetcher;
 import com.google.android.exoplayer.util.MimeTypes;
-import com.google.android.exoplayer.util.SystemClock;
-
-import android.os.Handler;
-import android.util.SparseArray;
 
 import java.io.IOException;
 import java.util.Arrays;
@@ -73,60 +65,29 @@ import java.util.List;
 // TODO[REFACTOR]: Handle multiple adaptation sets of the same type (at a higher level).
 public class DashChunkSource implements ChunkSource {
 
-  /**
-   * Interface definition for a callback to be notified of {@link DashChunkSource} events.
-   */
-  public interface EventListener {
-
-    /**
-     * Invoked when the available seek range of the stream has changed.
-     *
-     * @param sourceId The id of the reporting {@link DashChunkSource}.
-     * @param availableRange The range which specifies available content that can be seeked to.
-     */
-    public void onAvailableRangeChanged(int sourceId, TimeRange availableRange);
-
-  }
-
-  /**
-   * Thrown when an AdaptationSet is missing from the MPD.
-   */
-  public static class NoAdaptationSetException extends IOException {
-
-    public NoAdaptationSetException(String message) {
-      super(message);
-    }
-
-  }
-
-  private final Handler eventHandler;
-  private final EventListener eventListener;
-
   private final int adaptationSetType;
   private final DataSource dataSource;
   private final FormatEvaluator adaptiveFormatEvaluator;
   private final Evaluation evaluation;
   private final ManifestFetcher<MediaPresentationDescription> manifestFetcher;
-  private final SparseArray<PeriodHolder> periodHolders;
-  private final Clock systemClock;
   private final long liveEdgeLatencyUs;
-  private final long elapsedRealtimeOffsetUs;
-  private final long[] availableRangeValues;
-  private final int eventSourceId;
 
+  // Properties of the initial manifest.
   private boolean live;
   private long durationUs;
+
   private MediaPresentationDescription currentManifest;
-  private MediaPresentationDescription processedManifest;
+  private DrmInitData drmInitData;
-  private int nextPeriodHolderIndex;
+  private boolean indexIsUnbounded;
-  private TimeRange availableRange;
+  private boolean indexIsExplicit;
-  private boolean startAtLiveEdge;
+
   private boolean lastChunkWasInitialization;
   private IOException fatalError;
 
   // Properties of exposed tracks.
   private int adaptationSetIndex;
   private TrackGroup trackGroup;
+  private RepresentationHolder[] representationHolders;
 
   // Properties of enabled tracks.
   private Format[] enabledFormats;
@@ -144,75 +105,16 @@ public class DashChunkSource implements ChunkSource {
    *     manifest). Choosing a small value will minimize latency introduced by the player, however
    *     note that the value sets an upper bound on the length of media that the player can buffer.
    *     Hence a small value may increase the probability of rebuffering and playback failures.
-   * @param elapsedRealtimeOffsetMs If known, an estimate of the instantaneous difference between
-   *     server-side unix time and {@link SystemClock#elapsedRealtime()} in milliseconds, specified
-   *     as the server's unix time minus the local elapsed time. It unknown, set to 0.
-   * @param eventHandler A handler to use when delivering events to {@code EventListener}. May be
-   *     null if delivery of events is not required.
-   * @param eventListener A listener of events. May be null if delivery of events is not required.
-   * @param eventSourceId An identifier that gets passed to {@code eventListener} methods.
    */
   public DashChunkSource(ManifestFetcher<MediaPresentationDescription> manifestFetcher,
       int adaptationSetType, DataSource dataSource, FormatEvaluator adaptiveFormatEvaluator,
-      long liveEdgeLatencyMs, long elapsedRealtimeOffsetMs, Handler eventHandler,
+      long liveEdgeLatencyMs) {
-      EventListener eventListener, int eventSourceId) {
-    this(manifestFetcher, adaptationSetType, dataSource, adaptiveFormatEvaluator, new SystemClock(),
-        liveEdgeLatencyMs * 1000, elapsedRealtimeOffsetMs * 1000, true, eventHandler, eventListener,
-        eventSourceId);
-  }
-
-  /**
-   * Constructor to use for live DVR streaming.
-   *
-   * @param manifestFetcher A fetcher for the manifest.
-   * @param adaptationSetType The type of the adaptation set exposed by this source. One of
-   *     {@link AdaptationSet#TYPE_AUDIO}, {@link AdaptationSet#TYPE_VIDEO} and
-   *     {@link AdaptationSet#TYPE_TEXT}.
-   * @param dataSource A {@link DataSource} suitable for loading the media data.
-   * @param adaptiveFormatEvaluator For adaptive tracks, selects from the available formats.
-   * @param liveEdgeLatencyMs For live streams, the number of milliseconds that the playback should
-   *     lag behind the "live edge" (i.e. the end of the most recently defined media in the
-   *     manifest). Choosing a small value will minimize latency introduced by the player, however
-   *     note that the value sets an upper bound on the length of media that the player can buffer.
-   *     Hence a small value may increase the probability of rebuffering and playback failures.
-   * @param elapsedRealtimeOffsetMs If known, an estimate of the instantaneous difference between
-   *     server-side unix time and {@link SystemClock#elapsedRealtime()} in milliseconds, specified
-   *     as the server's unix time minus the local elapsed time. It unknown, set to 0.
-   * @param startAtLiveEdge True if the stream should start at the live edge; false if it should
-   *     at the beginning of the live window.
-   * @param eventHandler A handler to use when delivering events to {@code EventListener}. May be
-   *     null if delivery of events is not required.
-   * @param eventListener A listener of events. May be null if delivery of events is not required.
-   * @param eventSourceId An identifier that gets passed to {@code eventListener} methods.
-   */
-  public DashChunkSource(ManifestFetcher<MediaPresentationDescription> manifestFetcher,
-      int adaptationSetType, DataSource dataSource, FormatEvaluator adaptiveFormatEvaluator,
-      long liveEdgeLatencyMs, long elapsedRealtimeOffsetMs, boolean startAtLiveEdge,
-      Handler eventHandler, EventListener eventListener, int eventSourceId) {
-    this(manifestFetcher, adaptationSetType, dataSource, adaptiveFormatEvaluator, new SystemClock(),
-        liveEdgeLatencyMs * 1000, elapsedRealtimeOffsetMs * 1000, startAtLiveEdge, eventHandler,
-        eventListener, eventSourceId);
-  }
-
-  /* package */ DashChunkSource(ManifestFetcher<MediaPresentationDescription> manifestFetcher,
-      int adaptationSetType, DataSource dataSource, FormatEvaluator adaptiveFormatEvaluator,
-      Clock systemClock, long liveEdgeLatencyUs, long elapsedRealtimeOffsetUs,
-      boolean startAtLiveEdge, Handler eventHandler, EventListener eventListener,
-      int eventSourceId) {
     this.manifestFetcher = manifestFetcher;
     this.adaptationSetType = adaptationSetType;
     this.dataSource = dataSource;
     this.adaptiveFormatEvaluator = adaptiveFormatEvaluator;
-    this.systemClock = systemClock;
+    this.liveEdgeLatencyUs = liveEdgeLatencyMs * 1000;
-    this.liveEdgeLatencyUs = liveEdgeLatencyUs;
-    this.elapsedRealtimeOffsetUs = elapsedRealtimeOffsetUs;
-    this.startAtLiveEdge = startAtLiveEdge;
-    this.eventHandler = eventHandler;
-    this.eventListener = eventListener;
-    this.eventSourceId = eventSourceId;
     this.evaluation = new Evaluation();
-    this.availableRangeValues = new long[2];
-    periodHolders = new SparseArray<>();
   }
 
   // ChunkSource implementation.
@@ -235,8 +137,6 @@ public class DashChunkSource implements ChunkSource {
         manifestFetcher.requestRefresh();
         return false;
       } else {
-        live = currentManifest.dynamic;
-        durationUs = live ? C.UNKNOWN_TIME_US : currentManifest.duration * 1000;
         initForManifest(currentManifest);
       }
     }
@@ -274,11 +174,8 @@ public class DashChunkSource implements ChunkSource {
     }
 
     MediaPresentationDescription newManifest = manifestFetcher.getManifest();
-    if (newManifest != null && newManifest != processedManifest) {
+    if (newManifest != null && newManifest != currentManifest) {
       processManifest(newManifest);
-      // Manifests may be rejected, so the new manifest may not become the next currentManifest.
-      // Track a manifest has been processed to avoid processing twice when it was discarded.
-      processedManifest = newManifest;
     }
 
     // TODO: This is a temporary hack to avoid constantly refreshing the MPD in cases where
@@ -327,112 +224,76 @@ public class DashChunkSource implements ChunkSource {
       return;
     }
 
-    boolean startingNewPeriod;
-    PeriodHolder periodHolder;
-
-    availableRange.getCurrentBoundsUs(availableRangeValues);
-    if (previous == null) {
-      if (live) {
-        if (startAtLiveEdge) {
-          // We want live streams to start at the live edge instead of the beginning of the
-          // manifest
-          playbackPositionUs = Math.max(availableRangeValues[0],
-              availableRangeValues[1] - liveEdgeLatencyUs);
-        } else {
-          // we subtract 1 from the upper bound because it's exclusive for that bound
-          playbackPositionUs = Math.min(playbackPositionUs, availableRangeValues[1] - 1);
-          playbackPositionUs = Math.max(playbackPositionUs, availableRangeValues[0]);
-        }
-      }
-
-      periodHolder = findPeriodHolder(playbackPositionUs);
-      startingNewPeriod = true;
-    } else {
-      if (startAtLiveEdge) {
-        // now that we know the player is consuming media chunks (since the queue isn't empty),
-        // set startAtLiveEdge to false so that the user can perform seek operations
-        startAtLiveEdge = false;
-      }
-
-      long nextSegmentStartTimeUs = previous.endTimeUs;
-      if (live && nextSegmentStartTimeUs < availableRangeValues[0]) {
-        // This is before the first chunk in the current manifest.
-        fatalError = new BehindLiveWindowException();
-        return;
-      } else if (currentManifest.dynamic && nextSegmentStartTimeUs >= availableRangeValues[1]) {
-        // This chunk is beyond the last chunk in the current manifest. If the index is bounded
-        // we'll need to wait until it's refreshed. If it's unbounded we just need to wait for a
-        // while before attempting to load the chunk.
-        return;
-      } else {
-        // A period's duration is the maximum of its various representation's durations, so it's
-        // possible that due to the minor differences between them our available range values might
-        // not sync exactly with the actual available content, so double check whether or not we've
-        // really run out of content to play.
-        PeriodHolder lastPeriodHolder = periodHolders.valueAt(periodHolders.size() - 1);
-        if (previous.parentId == lastPeriodHolder.localIndex) {
-          RepresentationHolder representationHolder =
-              lastPeriodHolder.representationHolders[getTrackIndex(previous.format)];
-          if (representationHolder.isBeyondLastSegment(previous.getNextChunkIndex())) {
-            if (!currentManifest.dynamic) {
-              // The current manifest isn't dynamic, so we've reached the end of the stream.
-              out.endOfStream = true;
-            }
-            return;
-          }
-        }
-      }
-
-      startingNewPeriod = false;
-      periodHolder = periodHolders.get(previous.parentId);
-      if (periodHolder == null) {
-        // The previous chunk was from a period that's no longer on the manifest, therefore the
-        // next chunk must be the first one in the first period that's still on the manifest
-        // (note that we can't actually update the segmentNum yet because the new period might
-        // have a different sequence and its segmentIndex might not have been loaded yet).
-        periodHolder = periodHolders.valueAt(0);
-        startingNewPeriod = true;
-      } else if (!periodHolder.isIndexUnbounded()) {
-        RepresentationHolder representationHolder =
-            periodHolder.representationHolders[getTrackIndex(previous.format)];
-        if (representationHolder.isBeyondLastSegment(previous.getNextChunkIndex())) {
-          // We reached the end of a period. Start the next one.
-          periodHolder = periodHolders.get(previous.parentId + 1);
-          startingNewPeriod = true;
-        }
-      }
-    }
-
     RepresentationHolder representationHolder =
-        periodHolder.representationHolders[getTrackIndex(selectedFormat)];
+        representationHolders[getTrackIndex(selectedFormat)];
     Representation selectedRepresentation = representationHolder.representation;
+    DashSegmentIndex segmentIndex = representationHolder.segmentIndex;
 
     RangedUri pendingInitializationUri = null;
     RangedUri pendingIndexUri = null;
-
     Format sampleFormat = representationHolder.sampleFormat;
     if (sampleFormat == null) {
       pendingInitializationUri = selectedRepresentation.getInitializationUri();
     }
-    if (representationHolder.segmentIndex == null) {
+    if (segmentIndex == null) {
       pendingIndexUri = selectedRepresentation.getIndexUri();
     }
-
     if (pendingInitializationUri != null || pendingIndexUri != null) {
       // We have initialization and/or index requests to make.
       Chunk initializationChunk = newInitializationChunk(pendingInitializationUri, pendingIndexUri,
           selectedRepresentation, representationHolder.extractorWrapper, dataSource,
-          periodHolder.localIndex, evaluation.trigger);
+          evaluation.trigger);
       lastChunkWasInitialization = true;
       out.chunk = initializationChunk;
       return;
     }
 
-    int segmentNum = previous == null ? representationHolder.getSegmentNum(playbackPositionUs)
+    // TODO[REFACTOR]: Bring back UTC timing element support.
-          : startingNewPeriod ? representationHolder.getFirstAvailableSegmentNum()
+    long nowUs = System.currentTimeMillis() * 1000;
-          : previous.getNextChunkIndex();
+
-    Chunk nextMediaChunk = newMediaChunk(periodHolder, representationHolder, dataSource,
+    int firstAvailableSegmentNum = representationHolder.getFirstSegmentNum();
-        selectedFormat, sampleFormat, segmentNum, evaluation.trigger);
+    int lastAvailableSegmentNum = representationHolder.getLastSegmentNum();
+    boolean indexUnbounded = lastAvailableSegmentNum == DashSegmentIndex.INDEX_UNBOUNDED;
+    if (indexUnbounded) {
+      // The index is itself unbounded. We need to use the current time to calculate the range of
+      // available segments.
+      long liveEdgeTimestampUs = nowUs - currentManifest.availabilityStartTime * 1000;
+      if (currentManifest.timeShiftBufferDepth != -1) {
+        long bufferDepthUs = currentManifest.timeShiftBufferDepth * 1000;
+        firstAvailableSegmentNum = Math.max(firstAvailableSegmentNum,
+            representationHolder.getSegmentNum(liveEdgeTimestampUs - bufferDepthUs));
+      }
+      // getSegmentNum(liveEdgeTimestampUs) will not be completed yet, so subtract one to get the
+      // index of the last completed segment.
+      lastAvailableSegmentNum = representationHolder.getSegmentNum(liveEdgeTimestampUs) - 1;
+    }
+
+    int segmentNum;
+    if (previous == null) {
+      if (live) {
+        playbackPositionUs = getLiveSeekPosition(nowUs);
+      }
+      segmentNum = representationHolder.getSegmentNum(playbackPositionUs);
+    } else {
+      segmentNum = previous.getNextChunkIndex();
+    }
+
+    if (live && segmentNum < firstAvailableSegmentNum) {
+      // This is before the first chunk in the current manifest.
+      fatalError = new BehindLiveWindowException();
+      return;
+    } else if (currentManifest.dynamic) {
+      if (segmentNum > lastAvailableSegmentNum) {
+        // This is beyond the last chunk in the current manifest.
+        return;
+      }
+    } else if (segmentNum > lastAvailableSegmentNum) {
+      out.endOfStream = true;
+      return;
+    }
+
+    Chunk nextMediaChunk = newMediaChunk(representationHolder, dataSource, selectedFormat,
+        sampleFormat, segmentNum, evaluation.trigger);
     lastChunkWasInitialization = false;
     out.chunk = nextMediaChunk;
   }
@@ -441,14 +302,8 @@ public class DashChunkSource implements ChunkSource {
   public void onChunkLoadCompleted(Chunk chunk) {
     if (chunk instanceof InitializationChunk) {
       InitializationChunk initializationChunk = (InitializationChunk) chunk;
-      PeriodHolder periodHolder = periodHolders.get(initializationChunk.parentId);
-      if (periodHolder == null) {
-        // period for this initialization chunk may no longer be on the manifest
-        return;
-      }
-
       RepresentationHolder representationHolder =
-          periodHolder.representationHolders[getTrackIndex(initializationChunk.format)];
+          representationHolders[getTrackIndex(initializationChunk.format)];
       if (initializationChunk.hasSampleFormat()) {
         representationHolder.sampleFormat = initializationChunk.getSampleFormat();
       }
@@ -462,8 +317,8 @@ public class DashChunkSource implements ChunkSource {
       }
       // The null check avoids overwriting drmInitData obtained from the manifest with drmInitData
       // obtained from the stream, as per DASH IF Interoperability Recommendations V3.0, 7.5.3.
-      if (periodHolder.drmInitData == null && initializationChunk.hasDrmInitData()) {
+      if (drmInitData == null && initializationChunk.hasDrmInitData()) {
-        periodHolder.drmInitData = initializationChunk.getDrmInitData();
+        drmInitData = initializationChunk.getDrmInitData();
       }
     }
   }
@@ -479,9 +334,7 @@ public class DashChunkSource implements ChunkSource {
     if (enabledFormats.length > 1) {
       adaptiveFormatEvaluator.disable();
     }
-    periodHolders.clear();
     evaluation.clear();
-    availableRange = null;
     fatalError = null;
     enabledFormats = null;
   }
@@ -490,6 +343,9 @@ public class DashChunkSource implements ChunkSource {
 
   private void initForManifest(MediaPresentationDescription manifest) {
     Period period = manifest.getPeriod(0);
+    live = currentManifest.dynamic;
+    durationUs = live ? C.UNKNOWN_TIME_US : currentManifest.duration * 1000;
+
     for (int i = 0; i < period.adaptationSets.size(); i++) {
       AdaptationSet adaptationSet = period.adaptationSets.get(i);
       if (adaptationSet.type == adaptationSetType) {
@@ -497,11 +353,18 @@ public class DashChunkSource implements ChunkSource {
         List<Representation> representations = adaptationSet.representations;
         if (!representations.isEmpty()) {
           // We've found a non-empty adaptation set of the exposed type.
+          long periodDurationUs = getPeriodDurationUs(manifest, 0);
+          representationHolders = new RepresentationHolder[representations.size()];
           Format[] trackFormats = new Format[representations.size()];
           for (int j = 0; j < trackFormats.length; j++) {
-            trackFormats[j] = representations.get(j).format;
+            Representation representation = representations.get(j);
+            representationHolders[j] = new RepresentationHolder(periodDurationUs, representation);
+            trackFormats[j] = representation.format;
           }
           trackGroup = new TrackGroup(adaptiveFormatEvaluator != null, trackFormats);
+          drmInitData = getDrmInitData(adaptationSet);
+          updateRepresentationIndependentProperties(periodDurationUs,
+              representationHolders[0].representation);
           return;
         }
       }
@@ -509,14 +372,40 @@ public class DashChunkSource implements ChunkSource {
     trackGroup = null;
   }
 
-  // Visible for testing.
+  private void processManifest(MediaPresentationDescription newManifest) {
-  /* package */ TimeRange getAvailableRange() {
+    try {
-    return availableRange;
+      currentManifest = newManifest;
+      long periodDurationUs = getPeriodDurationUs(currentManifest, 0);
+      List<Representation> representations = currentManifest.getPeriod(0).adaptationSets
+          .get(adaptationSetIndex).representations;
+      for (int i = 0; i < representationHolders.length; i++) {
+        Representation representation = representations.get(i);
+        representationHolders[i].updateRepresentation(periodDurationUs, representation);
+      }
+      updateRepresentationIndependentProperties(periodDurationUs,
+          representationHolders[0].representation);
+    } catch (BehindLiveWindowException e) {
+      fatalError = e;
+      return;
+    }
+  }
+
+  private void updateRepresentationIndependentProperties(long periodDurationUs,
+      Representation arbitaryRepresentation) {
+    DashSegmentIndex segmentIndex = arbitaryRepresentation.getIndex();
+    if (segmentIndex != null) {
+      int lastSegmentNum = segmentIndex.getLastSegmentNum(periodDurationUs);
+      indexIsUnbounded = lastSegmentNum == DashSegmentIndex.INDEX_UNBOUNDED;
+      indexIsExplicit = segmentIndex.isExplicit();
+    } else {
+      indexIsUnbounded = false;
+      indexIsExplicit = true;
+    }
   }
 
   private Chunk newInitializationChunk(RangedUri initializationUri, RangedUri indexUri,
       Representation representation, ChunkExtractorWrapper extractor, DataSource dataSource,
-      int manifestIndex, int trigger) {
+      int trigger) {
     RangedUri requestUri;
     if (initializationUri != null) {
       // It's common for initialization and index data to be stored adjacently. Attempt to merge
@@ -531,12 +420,11 @@ public class DashChunkSource implements ChunkSource {
     DataSpec dataSpec = new DataSpec(requestUri.getUri(), requestUri.start, requestUri.length,
         representation.getCacheKey());
     return new InitializationChunk(dataSource, dataSpec, trigger, representation.format,
-        extractor, manifestIndex);
+        extractor);
   }
 
-  protected Chunk newMediaChunk(PeriodHolder periodHolder,
+  private Chunk newMediaChunk(RepresentationHolder representationHolder, DataSource dataSource,
-      RepresentationHolder representationHolder, DataSource dataSource, Format trackFormat,
+      Format trackFormat, Format sampleFormat, int segmentNum, int trigger) {
-      Format sampleFormat, int segmentNum, int trigger) {
     Representation representation = representationHolder.representation;
     long startTimeUs = representationHolder.getSegmentStartTimeUs(segmentNum);
     long endTimeUs = representationHolder.getSegmentEndTimeUs(segmentNum);
@@ -544,112 +432,43 @@ public class DashChunkSource implements ChunkSource {
     DataSpec dataSpec = new DataSpec(segmentUri.getUri(), segmentUri.start, segmentUri.length,
         representation.getCacheKey());
 
-    long sampleOffsetUs = periodHolder.startTimeUs - representation.presentationTimeOffsetUs;
     if (representationHolder.extractorWrapper == null) {
       return new SingleSampleMediaChunk(dataSource, dataSpec, Chunk.TRIGGER_INITIAL, trackFormat,
-          startTimeUs, endTimeUs, segmentNum, trackFormat, null, periodHolder.localIndex);
+          startTimeUs, endTimeUs, segmentNum, trackFormat, null);
     } else {
       boolean isSampleFormatFinal = sampleFormat != null;
+      long sampleOffsetUs = -representation.presentationTimeOffsetUs;
       return new ContainerMediaChunk(dataSource, dataSpec, trigger, trackFormat, startTimeUs,
           endTimeUs, segmentNum, sampleOffsetUs, representationHolder.extractorWrapper,
-          sampleFormat, periodHolder.drmInitData, isSampleFormatFinal, periodHolder.localIndex);
+          sampleFormat, drmInitData, isSampleFormatFinal);
     }
   }
 
-  private long getNowUnixTimeUs() {
+  /**
-    if (elapsedRealtimeOffsetUs != 0) {
+   * For live playbacks, determines the seek position that snaps playback to be
-      return (systemClock.elapsedRealtime() * 1000) + elapsedRealtimeOffsetUs;
+   * {@link #liveEdgeLatencyUs} behind the live edge of the current manifest
+   *
+   * @return The seek position in microseconds.
+   */
+  private long getLiveSeekPosition(long nowUs) {
+    long elapsedTimeUs = nowUs - currentManifest.availabilityStartTime * 1000;
+    long liveEdgeTimestampUs;
+    if (indexIsUnbounded) {
+      liveEdgeTimestampUs = elapsedTimeUs;
     } else {
-      return System.currentTimeMillis() * 1000;
+      liveEdgeTimestampUs = Long.MIN_VALUE;
-    }
+      for (RepresentationHolder representationHolder : representationHolders) {
-  }
+        int lastSegmentNum = representationHolder.getLastSegmentNum();
-
+        long indexLiveEdgeTimestampUs = representationHolder.getSegmentEndTimeUs(lastSegmentNum);
-  private PeriodHolder findPeriodHolder(long positionUs) {
+        liveEdgeTimestampUs = Math.max(liveEdgeTimestampUs, indexLiveEdgeTimestampUs);
-    // if positionUs is before the first period, return the first period
+      }
-    if (positionUs < periodHolders.valueAt(0).getAvailableStartTimeUs()) {
+      if (!indexIsExplicit) {
-      return periodHolders.valueAt(0);
+        // Some segments defined by the index may not be available yet. Bound the calculated live
-    }
+        // edge based on the elapsed time since the manifest became available.
-
+        liveEdgeTimestampUs = Math.min(liveEdgeTimestampUs, elapsedTimeUs);
-    for (int i = 0; i < periodHolders.size() - 1; i++) {
-      PeriodHolder periodHolder = periodHolders.valueAt(i);
-      if (positionUs < periodHolder.getAvailableEndTimeUs()) {
-        return periodHolder;
       }
     }
-
+    return liveEdgeTimestampUs - liveEdgeLatencyUs;
-    // positionUs is within or after the last period
-    return periodHolders.valueAt(periodHolders.size() - 1);
-  }
-
-  private void processManifest(MediaPresentationDescription manifest) {
-    // Remove old periods.
-    Period firstPeriod = manifest.getPeriod(0);
-    while (periodHolders.size() > 0
-        && periodHolders.valueAt(0).startTimeUs < firstPeriod.startMs * 1000) {
-      PeriodHolder periodHolder = periodHolders.valueAt(0);
-      // TODO: Use periodHolders.removeAt(0) if the minimum API level is ever increased to 11.
-      periodHolders.remove(periodHolder.localIndex);
-    }
-
-    // After discarding old periods, we should never have more periods than listed in the new
-    // manifest.  That would mean that a previously announced period is no longer advertised.  If
-    // this condition occurs, assume that we are hitting a manifest server that is out of sync and
-    // behind, discard this manifest, and try again later.
-    if (periodHolders.size() > manifest.getPeriodCount()) {
-      return;
-    }
-
-    // Update existing periods. Only the first and last periods can change.
-    try {
-      int periodHolderCount = periodHolders.size();
-      if (periodHolderCount > 0) {
-        periodHolders.valueAt(0).updatePeriod(manifest, 0, adaptationSetIndex);
-        if (periodHolderCount > 1) {
-          int lastIndex = periodHolderCount - 1;
-          periodHolders.valueAt(lastIndex).updatePeriod(manifest, lastIndex, adaptationSetIndex);
-        }
-      }
-    } catch (BehindLiveWindowException e) {
-      fatalError = e;
-      return;
-    }
-
-    // Add new periods.
-    for (int i = periodHolders.size(); i < manifest.getPeriodCount(); i++) {
-      PeriodHolder holder = new PeriodHolder(nextPeriodHolderIndex, manifest, i,
-          adaptationSetIndex);
-      periodHolders.put(nextPeriodHolderIndex, holder);
-      nextPeriodHolderIndex++;
-    }
-
-    // Update the available range.
-    TimeRange newAvailableRange = getAvailableRange(getNowUnixTimeUs());
-    if (availableRange == null || !availableRange.equals(newAvailableRange)) {
-      availableRange = newAvailableRange;
-      notifyAvailableRangeChanged(availableRange);
-    }
-
-    currentManifest = manifest;
-  }
-
-  private TimeRange getAvailableRange(long nowUnixTimeUs) {
-    PeriodHolder firstPeriod = periodHolders.valueAt(0);
-    PeriodHolder lastPeriod = periodHolders.valueAt(periodHolders.size() - 1);
-
-    if (!currentManifest.dynamic || lastPeriod.isIndexExplicit()) {
-      return new StaticTimeRange(firstPeriod.getAvailableStartTimeUs(),
-          lastPeriod.getAvailableEndTimeUs());
-    }
-
-    long minStartPositionUs = firstPeriod.getAvailableStartTimeUs();
-    long maxEndPositionUs = lastPeriod.isIndexUnbounded() ? Long.MAX_VALUE
-        : lastPeriod.getAvailableEndTimeUs();
-    long elapsedRealtimeAtZeroUs = (systemClock.elapsedRealtime() * 1000)
-        - (nowUnixTimeUs - (currentManifest.availabilityStartTime * 1000));
-    long timeShiftBufferDepthUs = currentManifest.timeShiftBufferDepth == -1 ? -1
-        : currentManifest.timeShiftBufferDepth * 1000;
-    return new DynamicTimeRange(minStartPositionUs, maxEndPositionUs, elapsedRealtimeAtZeroUs,
-        timeShiftBufferDepthUs, systemClock);
   }
 
   private int getTrackIndex(Format format) {
@@ -662,14 +481,26 @@ public class DashChunkSource implements ChunkSource {
     throw new IllegalStateException("Invalid format: " + format);
   }
 
-  private void notifyAvailableRangeChanged(final TimeRange seekRange) {
+  private static DrmInitData getDrmInitData(AdaptationSet adaptationSet) {
-    if (eventHandler != null && eventListener != null) {
+    DrmInitData.Mapped drmInitData = null;
-      eventHandler.post(new Runnable() {
+    for (int i = 0; i < adaptationSet.contentProtections.size(); i++) {
-        @Override
+      ContentProtection contentProtection = adaptationSet.contentProtections.get(i);
-        public void run() {
+      if (contentProtection.uuid != null && contentProtection.data != null) {
-          eventListener.onAvailableRangeChanged(eventSourceId, seekRange);
+        if (drmInitData == null) {
+          drmInitData = new DrmInitData.Mapped();
         }
-      });
+        drmInitData.put(contentProtection.uuid, contentProtection.data);
+      }
+    }
+    return drmInitData;
+  }
+
+  private static long getPeriodDurationUs(MediaPresentationDescription manifest, int index) {
+    long durationMs = manifest.getPeriodDuration(index);
+    if (durationMs == -1) {
+      return C.UNKNOWN_TIME_US;
+    } else {
+      return durationMs * 1000;
     }
   }
 
@@ -683,14 +514,10 @@ public class DashChunkSource implements ChunkSource {
     public DashSegmentIndex segmentIndex;
     public Format sampleFormat;
 
-    private final long periodStartTimeUs;
-
     private long periodDurationUs;
     private int segmentNumShift;
 
-    public RepresentationHolder(long periodStartTimeUs, long periodDurationUs,
+    public RepresentationHolder(long periodDurationUs, Representation representation) {
-        Representation representation) {
-      this.periodStartTimeUs = periodStartTimeUs;
       this.periodDurationUs = periodDurationUs;
       this.representation = representation;
       String containerMimeType = representation.format.containerMimeType;
@@ -738,13 +565,20 @@ public class DashChunkSource implements ChunkSource {
       }
     }
 
-    public int getSegmentNum(long positionUs) {
+    public int getFirstSegmentNum() {
-      return segmentIndex.getSegmentNum(positionUs - periodStartTimeUs, periodDurationUs)
+      return segmentIndex.getFirstSegmentNum() + segmentNumShift;
-          + segmentNumShift;
+    }
+
+    public int getLastSegmentNum() {
+      int lastSegmentNum = segmentIndex.getLastSegmentNum(periodDurationUs);
+      if (lastSegmentNum == DashSegmentIndex.INDEX_UNBOUNDED) {
+        return DashSegmentIndex.INDEX_UNBOUNDED;
+      }
+      return lastSegmentNum + segmentNumShift;
     }
 
     public long getSegmentStartTimeUs(int segmentNum) {
-      return segmentIndex.getTimeUs(segmentNum - segmentNumShift) + periodStartTimeUs;
+      return segmentIndex.getTimeUs(segmentNum - segmentNumShift);
     }
 
     public long getSegmentEndTimeUs(int segmentNum) {
@@ -752,18 +586,8 @@ public class DashChunkSource implements ChunkSource {
           + segmentIndex.getDurationUs(segmentNum - segmentNumShift, periodDurationUs);
     }
 
-    public int getLastSegmentNum() {
+    public int getSegmentNum(long positionUs) {
-      return segmentIndex.getLastSegmentNum(periodDurationUs);
+      return segmentIndex.getSegmentNum(positionUs, periodDurationUs) + segmentNumShift;
-    }
-
-    public boolean isBeyondLastSegment(int segmentNum) {
-      int lastSegmentNum = getLastSegmentNum();
-      return lastSegmentNum == DashSegmentIndex.INDEX_UNBOUNDED ? false
-          : segmentNum > (lastSegmentNum + segmentNumShift);
-    }
-
-    public int getFirstAvailableSegmentNum() {
-      return segmentIndex.getFirstSegmentNum() + segmentNumShift;
     }
 
     public RangedUri getSegmentUrl(int segmentNum) {
@@ -781,129 +605,4 @@ public class DashChunkSource implements ChunkSource {
 
   }
 
-  protected static final class PeriodHolder {
-
-    public final int localIndex;
-    public final long startTimeUs;
-    public final RepresentationHolder[] representationHolders;
-
-    private DrmInitData drmInitData;
-
-    private boolean indexIsUnbounded;
-    private boolean indexIsExplicit;
-    private long availableStartTimeUs;
-    private long availableEndTimeUs;
-
-    public PeriodHolder(int localIndex, MediaPresentationDescription manifest, int manifestIndex,
-        int adaptationSetIndex) {
-      this.localIndex = localIndex;
-
-      Period period = manifest.getPeriod(manifestIndex);
-      long periodDurationUs = getPeriodDurationUs(manifest, manifestIndex);
-      AdaptationSet adaptationSet = period.adaptationSets.get(adaptationSetIndex);
-      List<Representation> representations = adaptationSet.representations;
-
-      startTimeUs = period.startMs * 1000;
-      drmInitData = getDrmInitData(adaptationSet);
-
-      representationHolders = new RepresentationHolder[representations.size()];
-      for (int i = 0; i < representationHolders.length; i++) {
-        Representation representation = representations.get(i);
-        representationHolders[i] = new RepresentationHolder(startTimeUs,
-            periodDurationUs, representation);
-      }
-      updateRepresentationIndependentProperties(periodDurationUs,
-          representationHolders[0].representation);
-    }
-
-    public void updatePeriod(MediaPresentationDescription manifest, int manifestIndex,
-        int adaptationSetIndex) throws BehindLiveWindowException {
-      Period period = manifest.getPeriod(manifestIndex);
-      long periodDurationUs = getPeriodDurationUs(manifest, manifestIndex);
-      List<Representation> representations = period.adaptationSets
-          .get(adaptationSetIndex).representations;
-
-      for (int i = 0; i < representationHolders.length; i++) {
-        Representation representation = representations.get(i);
-        representationHolders[i].updateRepresentation(periodDurationUs, representation);
-      }
-      updateRepresentationIndependentProperties(periodDurationUs,
-          representationHolders[0].representation);
-    }
-
-    public long getAvailableStartTimeUs() {
-      return availableStartTimeUs;
-    }
-
-    public long getAvailableEndTimeUs() {
-      if (isIndexUnbounded()) {
-        throw new IllegalStateException("Period has unbounded index");
-      }
-      return availableEndTimeUs;
-    }
-
-    public boolean isIndexUnbounded() {
-      return indexIsUnbounded;
-    }
-
-    public boolean isIndexExplicit() {
-      return indexIsExplicit;
-    }
-
-    public DrmInitData getDrmInitData() {
-      return drmInitData;
-    }
-
-    // Private methods.
-
-    private void updateRepresentationIndependentProperties(long periodDurationUs,
-        Representation arbitaryRepresentation) {
-      DashSegmentIndex segmentIndex = arbitaryRepresentation.getIndex();
-      if (segmentIndex != null) {
-        int firstSegmentNum = segmentIndex.getFirstSegmentNum();
-        int lastSegmentNum = segmentIndex.getLastSegmentNum(periodDurationUs);
-        indexIsUnbounded = lastSegmentNum == DashSegmentIndex.INDEX_UNBOUNDED;
-        indexIsExplicit = segmentIndex.isExplicit();
-        availableStartTimeUs = startTimeUs + segmentIndex.getTimeUs(firstSegmentNum);
-        if (!indexIsUnbounded) {
-          availableEndTimeUs = startTimeUs + segmentIndex.getTimeUs(lastSegmentNum)
-              + segmentIndex.getDurationUs(lastSegmentNum, periodDurationUs);
-        }
-      } else {
-        indexIsUnbounded = false;
-        indexIsExplicit = true;
-        availableStartTimeUs = startTimeUs;
-        availableEndTimeUs = startTimeUs + periodDurationUs;
-      }
-    }
-
-    private static DrmInitData getDrmInitData(AdaptationSet adaptationSet) {
-      if (adaptationSet.contentProtections.isEmpty()) {
-        return null;
-      } else {
-        DrmInitData.Mapped drmInitData = null;
-        for (int i = 0; i < adaptationSet.contentProtections.size(); i++) {
-          ContentProtection contentProtection = adaptationSet.contentProtections.get(i);
-          if (contentProtection.uuid != null && contentProtection.data != null) {
-            if (drmInitData == null) {
-              drmInitData = new DrmInitData.Mapped();
-            }
-            drmInitData.put(contentProtection.uuid, contentProtection.data);
-          }
-        }
-        return drmInitData;
-      }
-    }
-
-    private static long getPeriodDurationUs(MediaPresentationDescription manifest, int index) {
-      long durationMs = manifest.getPeriodDuration(index);
-      if (durationMs == -1) {
-        return C.UNKNOWN_TIME_US;
-      } else {
-        return durationMs * 1000;
-      }
-    }
-
-  }
-
 }

library/src/main/java/com/google/android/exoplayer/hls/HlsChunkSource.java

@@ -727,7 +727,7 @@ public class HlsChunkSource {
         byte[] scratchSpace, HlsPlaylistParser playlistParser, int variantIndex,
         Uri playlistUri) {
       super(dataSource, dataSpec, Chunk.TYPE_MANIFEST, Chunk.TRIGGER_UNSPECIFIED, format,
-          Chunk.NO_PARENT_ID, scratchSpace);
+          scratchSpace);
       this.variantIndex = variantIndex;
       this.playlistParser = playlistParser;
       this.playlistUri = playlistUri;
@@ -754,7 +754,7 @@ public class HlsChunkSource {
     public EncryptionKeyChunk(DataSource dataSource, DataSpec dataSpec, Format format,
         byte[] scratchSpace, String iv) {
       super(dataSource, dataSpec, Chunk.TYPE_DRM, Chunk.TRIGGER_UNSPECIFIED, format,
-          Chunk.NO_PARENT_ID, scratchSpace);
+          scratchSpace);
       this.iv = iv;
     }
 

library/src/main/java/com/google/android/exoplayer/smoothstreaming/SmoothStreamingChunkSource.java

@@ -253,7 +253,7 @@ public class SmoothStreamingChunkSource implements ChunkSource {
       }
       chunkIndex = streamElement.getChunkIndex(playbackPositionUs);
     } else {
-      chunkIndex = previous.chunkIndex + 1 - currentManifestChunkOffset;
+      chunkIndex = previous.getNextChunkIndex() - currentManifestChunkOffset;
     }
 
     if (live && chunkIndex < 0) {
@@ -404,7 +404,7 @@ public class SmoothStreamingChunkSource implements ChunkSource {
     long sampleOffsetUs = chunkStartTimeUs;
     return new ContainerMediaChunk(dataSource, dataSpec, trigger, format, chunkStartTimeUs,
         chunkEndTimeUs, chunkIndex, sampleOffsetUs, extractorWrapper, sampleFormat, drmInitData,
-        true, Chunk.NO_PARENT_ID);
+        true);
   }
 
   private static byte[] getProtectionElementKeyId(byte[] initData) {

library/src/main/java/com/google/android/exoplayer/upstream/DefaultBandwidthMeter.java

@@ -16,11 +16,10 @@
 package com.google.android.exoplayer.upstream;
 
 import com.google.android.exoplayer.util.Assertions;
-import com.google.android.exoplayer.util.Clock;
 import com.google.android.exoplayer.util.SlidingPercentile;
-import com.google.android.exoplayer.util.SystemClock;
 
 import android.os.Handler;
+import android.os.SystemClock;
 
 /**
  * Counts transferred bytes while transfers are open and creates a bandwidth sample and updated
@@ -35,7 +34,6 @@ public final class DefaultBandwidthMeter implements BandwidthMeter {
 
   private final Handler eventHandler;
   private final EventListener eventListener;
-  private final Clock clock;
   private final SlidingPercentile slidingPercentile;
 
   private int streamCount;
@@ -51,22 +49,12 @@ public final class DefaultBandwidthMeter implements BandwidthMeter {
   }
 
   public DefaultBandwidthMeter(Handler eventHandler, EventListener eventListener) {
-    this(eventHandler, eventListener, new SystemClock());
+    this(eventHandler, eventListener, DEFAULT_MAX_WEIGHT);
-  }
-
-  public DefaultBandwidthMeter(Handler eventHandler, EventListener eventListener, Clock clock) {
-    this(eventHandler, eventListener, clock, DEFAULT_MAX_WEIGHT);
   }
 
   public DefaultBandwidthMeter(Handler eventHandler, EventListener eventListener, int maxWeight) {
-    this(eventHandler, eventListener, new SystemClock(), maxWeight);
-  }
-
-  public DefaultBandwidthMeter(Handler eventHandler, EventListener eventListener, Clock clock,
-      int maxWeight) {
     this.eventHandler = eventHandler;
     this.eventListener = eventListener;
-    this.clock = clock;
     this.slidingPercentile = new SlidingPercentile(maxWeight);
     bitrateEstimate = NO_ESTIMATE;
   }
@@ -79,7 +67,7 @@ public final class DefaultBandwidthMeter implements BandwidthMeter {
   @Override
   public synchronized void onTransferStart() {
     if (streamCount == 0) {
-      sampleStartTimeMs = clock.elapsedRealtime();
+      sampleStartTimeMs = SystemClock.elapsedRealtime();
     }
     streamCount++;
   }
@@ -92,7 +80,7 @@ public final class DefaultBandwidthMeter implements BandwidthMeter {
   @Override
   public synchronized void onTransferEnd() {
     Assertions.checkState(streamCount > 0);
-    long nowMs = clock.elapsedRealtime();
+    long nowMs = SystemClock.elapsedRealtime();
     int sampleElapsedTimeMs = (int) (nowMs - sampleStartTimeMs);
     totalElapsedTimeMs += sampleElapsedTimeMs;
     totalBytesTransferred += sampleBytesTransferred;

library/src/main/java/com/google/android/exoplayer/util/SystemClock.java

@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2014 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.exoplayer.util;
-
-/**
- * The standard implementation of {@link Clock}.
- */
-public final class SystemClock implements Clock {
-
-  @Override
-  public long elapsedRealtime() {
-    return android.os.SystemClock.elapsedRealtime();
-  }
-
-}