Skip to content

SDK / exoplayer

Go to a project
Commit 060ca4ae by olly Committed by Oliver Woodman
Options

ExoPlayerImplInternal cleanup 

- Make handleSourceInfoRefreshed clearer.
- Remove bufferAheadPeriodCount. Seems error prone.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=139774580
parent adc9dd1c
Inline Side-by-side
Showing with 98 additions and 125 deletions
library/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java
...@@ -63,6 +63,13 @@ import java.io.IOException; ...@@ -63,6 +63,13 @@ import java.io.IOException;
bufferedPositionUs = startPositionUs; bufferedPositionUs = startPositionUs;
} }
public PlaybackInfo copyWithPeriodIndex(int periodIndex) {
PlaybackInfo playbackInfo = new PlaybackInfo(periodIndex, startPositionUs);
playbackInfo.positionUs = positionUs;
playbackInfo.bufferedPositionUs = bufferedPositionUs;
return playbackInfo;
}
} }
public static final class TrackInfo { public static final class TrackInfo {
...@@ -161,7 +168,6 @@ import java.io.IOException; ...@@ -161,7 +168,6 @@ import java.io.IOException;
private boolean isTimelineReady; private boolean isTimelineReady;
private boolean isTimelineEnded; private boolean isTimelineEnded;
private int bufferAheadPeriodCount;
private MediaPeriodHolder playingPeriodHolder; private MediaPeriodHolder playingPeriodHolder;
private MediaPeriodHolder readingPeriodHolder; private MediaPeriodHolder readingPeriodHolder;
private MediaPeriodHolder loadingPeriodHolder; private MediaPeriodHolder loadingPeriodHolder;
...@@ -603,7 +609,6 @@ import java.io.IOException; ...@@ -603,7 +609,6 @@ import java.io.IOException;
} }
// Update loaded periods. // Update loaded periods.
bufferAheadPeriodCount = 0;
if (newPlayingPeriodHolder != null) { if (newPlayingPeriodHolder != null) {
newPlayingPeriodHolder.next = null; newPlayingPeriodHolder.next = null;
setPlayingPeriodHolder(newPlayingPeriodHolder); setPlayingPeriodHolder(newPlayingPeriodHolder);
...@@ -679,7 +684,6 @@ import java.io.IOException; ...@@ -679,7 +684,6 @@ import java.io.IOException;
readingPeriodHolder = null; readingPeriodHolder = null;
loadingPeriodHolder = null; loadingPeriodHolder = null;
timeline = null; timeline = null;
bufferAheadPeriodCount = 0;
setIsLoading(false); setIsLoading(false);
} }
...@@ -737,11 +741,10 @@ import java.io.IOException; ...@@ -737,11 +741,10 @@ import java.io.IOException;
playingPeriodHolder.next = null; playingPeriodHolder.next = null;
readingPeriodHolder = playingPeriodHolder; readingPeriodHolder = playingPeriodHolder;
loadingPeriodHolder = playingPeriodHolder; loadingPeriodHolder = playingPeriodHolder;
bufferAheadPeriodCount = 0;
boolean[] streamResetFlags = new boolean[renderers.length]; boolean[] streamResetFlags = new boolean[renderers.length];
long periodPositionUs = playingPeriodHolder.updatePeriodTrackSelection( long periodPositionUs = playingPeriodHolder.updatePeriodTrackSelection(
playbackInfo.positionUs, loadControl, recreateStreams, streamResetFlags); playbackInfo.positionUs, recreateStreams, streamResetFlags);
if (periodPositionUs != playbackInfo.positionUs) { if (periodPositionUs != playbackInfo.positionUs) {
playbackInfo.positionUs = periodPositionUs; playbackInfo.positionUs = periodPositionUs;
resetRendererPosition(periodPositionUs); resetRendererPosition(periodPositionUs);
...@@ -786,13 +789,12 @@ import java.io.IOException; ...@@ -786,13 +789,12 @@ import java.io.IOException;
while (periodHolder != null) { while (periodHolder != null) {
periodHolder.release(); periodHolder.release();
periodHolder = periodHolder.next; periodHolder = periodHolder.next;
bufferAheadPeriodCount--;
} }
loadingPeriodHolder.next = null; loadingPeriodHolder.next = null;
if (loadingPeriodHolder.prepared) { if (loadingPeriodHolder.prepared) {
long loadingPeriodPositionUs = Math.max(loadingPeriodHolder.startPositionUs, long loadingPeriodPositionUs = Math.max(loadingPeriodHolder.startPositionUs,
loadingPeriodHolder.toPeriodTime(rendererPositionUs)); loadingPeriodHolder.toPeriodTime(rendererPositionUs));
loadingPeriodHolder.updatePeriodTrackSelection(loadingPeriodPositionUs, loadControl, false); loadingPeriodHolder.updatePeriodTrackSelection(loadingPeriodPositionUs, false);
} }
} }
maybeContinueLoading(); maybeContinueLoading();
...@@ -832,7 +834,7 @@ import java.io.IOException; ...@@ -832,7 +834,7 @@ import java.io.IOException;
} }
private void handleSourceInfoRefreshed(Pair<Timeline, Object> timelineAndManifest) private void handleSourceInfoRefreshed(Pair<Timeline, Object> timelineAndManifest)
throws ExoPlaybackException, IOException { throws ExoPlaybackException {
Timeline oldTimeline = timeline; Timeline oldTimeline = timeline;
timeline = timelineAndManifest.first; timeline = timelineAndManifest.first;
Object manifest = timelineAndManifest.second; Object manifest = timelineAndManifest.second;
...@@ -841,9 +843,9 @@ import java.io.IOException; ...@@ -841,9 +843,9 @@ import java.io.IOException;
if (pendingInitialSeekCount > 0) { if (pendingInitialSeekCount > 0) {
Pair<Integer, Long> periodPosition = resolveSeekPosition(pendingSeekPosition); Pair<Integer, Long> periodPosition = resolveSeekPosition(pendingSeekPosition);
if (periodPosition == null) { if (periodPosition == null) {
// TODO: We should probably propagate an error here.
// We failed to resolve the seek position. Stop the player. // We failed to resolve the seek position. Stop the player.
finishSourceInfoRefresh(manifest, false); finishSourceInfoRefresh(manifest, false);
// TODO: We should probably propagate an error here.
stopInternal(); stopInternal();
return; return;
} }
...@@ -854,11 +856,18 @@ import java.io.IOException; ...@@ -854,11 +856,18 @@ import java.io.IOException;
} }
} }
// Update the loaded periods to take into account the new timeline. MediaPeriodHolder periodHolder = playingPeriodHolder != null ? playingPeriodHolder
if (playingPeriodHolder != null) { : loadingPeriodHolder;
int index = timeline.getIndexOfPeriod(playingPeriodHolder.uid); if (periodHolder == null) {
if (index == C.INDEX_UNSET) { // We don't have any period holders, so we're done.
boolean restarted = attemptRestart(playingPeriodHolder.index, oldTimeline, timeline); finishSourceInfoRefresh(manifest, true);
return;
}
int periodIndex = timeline.getIndexOfPeriod(periodHolder.uid);
if (periodIndex == C.INDEX_UNSET) {
// We didn't find the current period in the new timeline. Attempt to restart.
boolean restarted = attemptRestart(periodHolder, oldTimeline, timeline);
finishSourceInfoRefresh(manifest, true); finishSourceInfoRefresh(manifest, true);
if (!restarted) { if (!restarted) {
// TODO: We should probably propagate an error here. // TODO: We should probably propagate an error here.
...@@ -867,94 +876,68 @@ import java.io.IOException; ...@@ -867,94 +876,68 @@ import java.io.IOException;
return; return;
} }
// The playing period is also in the new timeline. Update the index for each loaded period // The current period is in the new timeline. Update the holder and playbackInfo.
// until a period is found that does not match the old timeline. timeline.getPeriod(periodIndex, period);
timeline.getPeriod(index, period, true); boolean isLastPeriod = periodIndex == timeline.getPeriodCount() - 1
playingPeriodHolder.setIndex(timeline, timeline.getWindow(period.windowIndex, window), && !timeline.getWindow(period.windowIndex, window).isDynamic;
index); periodHolder.setIndex(periodIndex, isLastPeriod);
if (periodIndex != playbackInfo.periodIndex) {
playbackInfo = playbackInfo.copyWithPeriodIndex(periodIndex);
}
MediaPeriodHolder previousPeriodHolder = playingPeriodHolder; // If there are subsequent holders, update the index for each of them. If we find a holder
// that's inconsistent with the new timeline then take appropriate action.
boolean seenReadingPeriod = false; boolean seenReadingPeriod = false;
bufferAheadPeriodCount = 0; while (periodHolder.next != null) {
while (previousPeriodHolder.next != null) { MediaPeriodHolder previousPeriodHolder = periodHolder;
MediaPeriodHolder periodHolder = previousPeriodHolder.next; periodHolder = periodHolder.next;
index++; periodIndex++;
timeline.getPeriod(index, period, true); timeline.getPeriod(periodIndex, period, true);
if (!periodHolder.uid.equals(period.uid)) { isLastPeriod = periodIndex == timeline.getPeriodCount() - 1
&& !timeline.getWindow(period.windowIndex, window).isDynamic;
if (periodHolder.uid.equals(period.uid)) {
// The holder is consistent with the new timeline. Update its index and continue.
periodHolder.setIndex(periodIndex, isLastPeriod);
seenReadingPeriod |= (periodHolder == readingPeriodHolder);
} else {
// The holder is inconsistent with the new timeline.
if (!seenReadingPeriod) { if (!seenReadingPeriod) {
// Renderers may have read a period that has been removed, so release all loaded periods // Renderers may have read from a period that's been removed, so release all loaded
// and seek to the current position of the playing period index. // periods and seek to the current position of the playing period index.
index = playingPeriodHolder.index; periodIndex = playingPeriodHolder.index;
releasePeriodHoldersFrom(playingPeriodHolder); releasePeriodHoldersFrom(playingPeriodHolder);
playingPeriodHolder = null; playingPeriodHolder = null;
readingPeriodHolder = null; readingPeriodHolder = null;
loadingPeriodHolder = null; loadingPeriodHolder = null;
long newPositionUs = seekToPeriodPosition(index, playbackInfo.positionUs); long newPositionUs = seekToPeriodPosition(periodIndex, playbackInfo.positionUs);
if (newPositionUs != playbackInfo.positionUs) { if (newPositionUs != playbackInfo.positionUs) {
playbackInfo = new PlaybackInfo(index, newPositionUs); playbackInfo = new PlaybackInfo(periodIndex, newPositionUs);
} }
finishSourceInfoRefresh(manifest, true); } else {
return; // Update the loading period to be the last period that's still valid, and release all
} // subsequent periods.
// Update the loading period to be the latest period that is still valid.
loadingPeriodHolder = previousPeriodHolder; loadingPeriodHolder = previousPeriodHolder;
loadingPeriodHolder.next = null; loadingPeriodHolder.next = null;
// Release the rest of the timeline. // Release the rest of the timeline.
releasePeriodHoldersFrom(periodHolder); releasePeriodHoldersFrom(periodHolder);
break;
}
bufferAheadPeriodCount++;
int windowIndex = timeline.getPeriod(index, period).windowIndex;
periodHolder.setIndex(timeline, timeline.getWindow(windowIndex, window), index);
if (periodHolder == readingPeriodHolder) {
seenReadingPeriod = true;
}
previousPeriodHolder = periodHolder;
}
} else if (loadingPeriodHolder != null) {
Object uid = loadingPeriodHolder.uid;
int index = timeline.getIndexOfPeriod(uid);
if (index == C.INDEX_UNSET) {
boolean restarted = attemptRestart(loadingPeriodHolder.index, oldTimeline, timeline);
finishSourceInfoRefresh(manifest, true);
if (!restarted) {
// TODO: We should probably propagate an error here.
stopInternal();
} }
return; break;
} else {
int windowIndex = timeline.getPeriod(index, this.period).windowIndex;
loadingPeriodHolder.setIndex(timeline, timeline.getWindow(windowIndex, window),
index);
} }
} }
if (oldTimeline != null) {
int newPlayingIndex = playingPeriodHolder != null ? playingPeriodHolder.index
: loadingPeriodHolder != null ? loadingPeriodHolder.index : C.INDEX_UNSET;
if (newPlayingIndex != C.INDEX_UNSET
&& newPlayingIndex != playbackInfo.periodIndex) {
playbackInfo = new PlaybackInfo(newPlayingIndex, playbackInfo.positionUs);
updatePlaybackPositions();
}
}
finishSourceInfoRefresh(manifest, true); finishSourceInfoRefresh(manifest, true);
} }
private boolean attemptRestart(int oldPeriodIndex, Timeline oldTimeline, Timeline newTimeline) { private boolean attemptRestart(MediaPeriodHolder oldPeriodHolder, Timeline oldTimeline,
int newPeriodIndex = resolveSubsequentPeriod(oldPeriodIndex, oldTimeline, newTimeline); Timeline newTimeline) {
int newPeriodIndex = resolveSubsequentPeriod(oldPeriodHolder.index, oldTimeline, newTimeline);
if (newPeriodIndex == C.INDEX_UNSET) { if (newPeriodIndex == C.INDEX_UNSET) {
// We failed to find a replacement period. Stop the player. // We failed to find a replacement period. Stop the player.
return false; return false;
} }
// Release all loaded periods. // Release all loaded periods.
releasePeriodHoldersFrom(playingPeriodHolder != null ? playingPeriodHolder releasePeriodHoldersFrom(oldPeriodHolder);
: loadingPeriodHolder);
bufferAheadPeriodCount = 0;
playingPeriodHolder = null; playingPeriodHolder = null;
readingPeriodHolder = null; readingPeriodHolder = null;
loadingPeriodHolder = null; loadingPeriodHolder = null;
...@@ -1095,7 +1078,8 @@ import java.io.IOException; ...@@ -1095,7 +1078,8 @@ import java.io.IOException;
if (loadingPeriodHolder == null if (loadingPeriodHolder == null
|| (loadingPeriodHolder.isFullyBuffered() && !loadingPeriodHolder.isLast || (loadingPeriodHolder.isFullyBuffered() && !loadingPeriodHolder.isLast
&& bufferAheadPeriodCount < MAXIMUM_BUFFER_AHEAD_PERIODS)) { && (playingPeriodHolder == null
|| loadingPeriodHolder.index - playingPeriodHolder.index < MAXIMUM_BUFFER_AHEAD_PERIODS))) {
// We don't have a loading period or it's fully loaded, so try and create the next one. // We don't have a loading period or it's fully loaded, so try and create the next one.
int newLoadingPeriodIndex = loadingPeriodHolder == null ? playbackInfo.periodIndex int newLoadingPeriodIndex = loadingPeriodHolder == null ? playbackInfo.periodIndex
: loadingPeriodHolder.index + 1; : loadingPeriodHolder.index + 1;
...@@ -1119,9 +1103,9 @@ import java.io.IOException; ...@@ -1119,9 +1103,9 @@ import java.io.IOException;
// transitions is equal the duration of media that's currently buffered (assuming no // transitions is equal the duration of media that's currently buffered (assuming no
// interruptions). Hence we project the default start position forward by the duration of // interruptions). Hence we project the default start position forward by the duration of
// the buffer, and start buffering from this point. // the buffer, and start buffering from this point.
long defaultPositionProjectionUs = loadingPeriodHolder.rendererPositionOffsetUs long defaultPositionProjectionUs = loadingPeriodHolder.getRendererOffset()
+ timeline.getPeriod(loadingPeriodHolder.index, period).getDurationUs() + timeline.getPeriod(loadingPeriodHolder.index, period).getDurationUs()
- loadingPeriodHolder.startPositionUs - rendererPositionUs; - rendererPositionUs;
Pair<Integer, Long> defaultPosition = getPeriodPosition(timeline, windowIndex, Pair<Integer, Long> defaultPosition = getPeriodPosition(timeline, windowIndex,
C.TIME_UNSET, Math.max(0, defaultPositionProjectionUs)); C.TIME_UNSET, Math.max(0, defaultPositionProjectionUs));
if (defaultPosition == null) { if (defaultPosition == null) {
...@@ -1133,24 +1117,20 @@ import java.io.IOException; ...@@ -1133,24 +1117,20 @@ import java.io.IOException;
} }
} }
if (newLoadingPeriodIndex != C.INDEX_UNSET) { if (newLoadingPeriodIndex != C.INDEX_UNSET) {
Object newPeriodUid = timeline.getPeriod(newLoadingPeriodIndex, period, true).uid; long rendererPositionOffsetUs = loadingPeriodHolder == null ? periodStartPositionUs
MediaPeriod newMediaPeriod = mediaSource.createPeriod(newLoadingPeriodIndex, : (loadingPeriodHolder.getRendererOffset()
loadControl.getAllocator(), periodStartPositionUs); + timeline.getPeriod(loadingPeriodHolder.index, period).getDurationUs());
newMediaPeriod.prepare(this); timeline.getPeriod(newLoadingPeriodIndex, period, true);
boolean isLastPeriod = newLoadingPeriodIndex == timeline.getPeriodCount() - 1
&& !timeline.getWindow(period.windowIndex, window).isDynamic;
MediaPeriodHolder newPeriodHolder = new MediaPeriodHolder(renderers, rendererCapabilities, MediaPeriodHolder newPeriodHolder = new MediaPeriodHolder(renderers, rendererCapabilities,
trackSelector, mediaSource, newMediaPeriod, newPeriodUid, periodStartPositionUs); rendererPositionOffsetUs, trackSelector, loadControl, mediaSource, period.uid,
timeline.getWindow(windowIndex, window); newLoadingPeriodIndex, isLastPeriod, periodStartPositionUs);
newPeriodHolder.setIndex(timeline, window, newLoadingPeriodIndex);
if (loadingPeriodHolder != null) { if (loadingPeriodHolder != null) {
loadingPeriodHolder.setNext(newPeriodHolder); loadingPeriodHolder.next = newPeriodHolder;
newPeriodHolder.rendererPositionOffsetUs = loadingPeriodHolder.rendererPositionOffsetUs
+ timeline.getPeriod(loadingPeriodHolder.index, period).getDurationUs()
- loadingPeriodHolder.startPositionUs;
} else {
newPeriodHolder.rendererPositionOffsetUs = periodStartPositionUs;
} }
bufferAheadPeriodCount++;
loadingPeriodHolder = newPeriodHolder; loadingPeriodHolder = newPeriodHolder;
loadingPeriodHolder.mediaPeriod.prepare(this);
setIsLoading(true); setIsLoading(true);
} }
} }
...@@ -1168,13 +1148,12 @@ import java.io.IOException; ...@@ -1168,13 +1148,12 @@ import java.io.IOException;
} }
// Update the playing and reading periods. // Update the playing and reading periods.
while (playingPeriodHolder != readingPeriodHolder && playingPeriodHolder.next != null while (playingPeriodHolder != readingPeriodHolder
&& rendererPositionUs >= playingPeriodHolder.next.rendererPositionOffsetUs) { && rendererPositionUs >= playingPeriodHolder.next.rendererPositionOffsetUs) {
// All enabled renderers' streams have been read to the end, and the playback position reached // 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. // the end of the playing period, so advance playback to the next period.
playingPeriodHolder.release(); playingPeriodHolder.release();
setPlayingPeriodHolder(playingPeriodHolder.next); setPlayingPeriodHolder(playingPeriodHolder.next);
bufferAheadPeriodCount--;
playbackInfo = new PlaybackInfo(playingPeriodHolder.index, playbackInfo = new PlaybackInfo(playingPeriodHolder.index,
playingPeriodHolder.startPositionUs); playingPeriodHolder.startPositionUs);
updatePlaybackPositions(); updatePlaybackPositions();
...@@ -1228,18 +1207,11 @@ import java.io.IOException; ...@@ -1228,18 +1207,11 @@ import java.io.IOException;
// Stale event. // Stale event.
return; return;
} }
loadingPeriodHolder.handlePrepared(loadingPeriodHolder.startPositionUs, loadControl); loadingPeriodHolder.handlePrepared();
if (playingPeriodHolder == null) { if (playingPeriodHolder == null) {
// This is the first prepared period, so start playing it. // This is the first prepared period, so start playing it.
readingPeriodHolder = loadingPeriodHolder; readingPeriodHolder = loadingPeriodHolder;
setPlayingPeriodHolder(readingPeriodHolder); setPlayingPeriodHolder(readingPeriodHolder);
if (playbackInfo.startPositionUs == C.TIME_UNSET) {
// Update the playback info when seeking to a default position.
playbackInfo = new PlaybackInfo(playingPeriodHolder.index,
playingPeriodHolder.startPositionUs);
updatePlaybackPositions();
eventHandler.obtainMessage(MSG_POSITION_DISCONTINUITY, playbackInfo).sendToTarget();
}
updateTimelineState(); updateTimelineState();
} }
maybeContinueLoading(); maybeContinueLoading();
...@@ -1247,6 +1219,7 @@ import java.io.IOException; ...@@ -1247,6 +1219,7 @@ import java.io.IOException;
private void handleContinueLoadingRequested(MediaPeriod period) { private void handleContinueLoadingRequested(MediaPeriod period) {
if (loadingPeriodHolder == null || loadingPeriodHolder.mediaPeriod != period) { if (loadingPeriodHolder == null || loadingPeriodHolder.mediaPeriod != period) {
// Stale event.
return; return;
} }
maybeContinueLoading(); maybeContinueLoading();
...@@ -1366,22 +1339,22 @@ import java.io.IOException; ...@@ -1366,22 +1339,22 @@ import java.io.IOException;
public final MediaPeriod mediaPeriod; public final MediaPeriod mediaPeriod;
public final Object uid; public final Object uid;
public final SampleStream[] sampleStreams; public final SampleStream[] sampleStreams;
public final boolean[] mayRetainStreamFlags; public final boolean[] mayRetainStreamFlags;
public final long rendererPositionOffsetUs;
public int index; public int index;
public long startPositionUs; public long startPositionUs;
public boolean isLast; public boolean isLast;
public boolean prepared; public boolean prepared;
public boolean hasEnabledTracks; public boolean hasEnabledTracks;
public long rendererPositionOffsetUs;
public MediaPeriodHolder next; public MediaPeriodHolder next;
public boolean needsContinueLoading; public boolean needsContinueLoading;
private final Renderer[] renderers; private final Renderer[] renderers;
private final RendererCapabilities[] rendererCapabilities; private final RendererCapabilities[] rendererCapabilities;
private final TrackSelector trackSelector; private final TrackSelector trackSelector;
private final LoadControl loadControl;
private final MediaSource mediaSource; private final MediaSource mediaSource;
private Object trackSelectionsInfo; private Object trackSelectionsInfo;
...@@ -1390,17 +1363,23 @@ import java.io.IOException; ...@@ -1390,17 +1363,23 @@ import java.io.IOException;
private TrackSelectionArray periodTrackSelections; private TrackSelectionArray periodTrackSelections;
public MediaPeriodHolder(Renderer[] renderers, RendererCapabilities[] rendererCapabilities, public MediaPeriodHolder(Renderer[] renderers, RendererCapabilities[] rendererCapabilities,
TrackSelector trackSelector, MediaSource mediaSource, MediaPeriod mediaPeriod, long rendererPositionOffsetUs, TrackSelector trackSelector, LoadControl loadControl,
Object uid, long positionUs) { MediaSource mediaSource, Object periodUid, int periodIndex, boolean isLastPeriod,
long startPositionUs) {
this.renderers = renderers; this.renderers = renderers;
this.rendererCapabilities = rendererCapabilities; this.rendererCapabilities = rendererCapabilities;
this.rendererPositionOffsetUs = rendererPositionOffsetUs;
this.trackSelector = trackSelector; this.trackSelector = trackSelector;
this.loadControl = loadControl;
this.mediaSource = mediaSource; this.mediaSource = mediaSource;
this.mediaPeriod = mediaPeriod; this.uid = Assertions.checkNotNull(periodUid);
this.uid = Assertions.checkNotNull(uid); this.index = periodIndex;
this.isLast = isLastPeriod;
this.startPositionUs = startPositionUs;
sampleStreams = new SampleStream[renderers.length]; sampleStreams = new SampleStream[renderers.length];
mayRetainStreamFlags = new boolean[renderers.length]; mayRetainStreamFlags = new boolean[renderers.length];
startPositionUs = positionUs; mediaPeriod = mediaSource.createPeriod(periodIndex, loadControl.getAllocator(),
startPositionUs);
} }
public long toRendererTime(long periodTimeUs) { public long toRendererTime(long periodTimeUs) {
...@@ -1415,13 +1394,9 @@ import java.io.IOException; ...@@ -1415,13 +1394,9 @@ import java.io.IOException;
return rendererPositionOffsetUs - startPositionUs; return rendererPositionOffsetUs - startPositionUs;
} }
public void setNext(MediaPeriodHolder next) { public void setIndex(int index, boolean isLast) {
this.next = next; this.index = index;
} this.isLast = isLast;
public void setIndex(Timeline timeline, Timeline.Window window, int periodIndex) {
this.index = periodIndex;
isLast = index == timeline.getPeriodCount() - 1 && !window.isDynamic;
} }
public boolean isFullyBuffered() { public boolean isFullyBuffered() {
...@@ -1429,12 +1404,11 @@ import java.io.IOException; ...@@ -1429,12 +1404,11 @@ import java.io.IOException;
&& (!hasEnabledTracks || mediaPeriod.getBufferedPositionUs() == C.TIME_END_OF_SOURCE); && (!hasEnabledTracks || mediaPeriod.getBufferedPositionUs() == C.TIME_END_OF_SOURCE);
} }
public void handlePrepared(long positionUs, LoadControl loadControl) public void handlePrepared() throws ExoPlaybackException {
throws ExoPlaybackException {
prepared = true; prepared = true;
trackGroups = mediaPeriod.getTrackGroups(); trackGroups = mediaPeriod.getTrackGroups();
selectTracks(); selectTracks();
startPositionUs = updatePeriodTrackSelection(positionUs, loadControl, false); startPositionUs = updatePeriodTrackSelection(startPositionUs, false);
} }
public boolean selectTracks() throws ExoPlaybackException { public boolean selectTracks() throws ExoPlaybackException {
...@@ -1449,14 +1423,13 @@ import java.io.IOException; ...@@ -1449,14 +1423,13 @@ import java.io.IOException;
return true; return true;
} }
public long updatePeriodTrackSelection(long positionUs, LoadControl loadControl, public long updatePeriodTrackSelection(long positionUs, boolean forceRecreateStreams) {
boolean forceRecreateStreams) throws ExoPlaybackException { return updatePeriodTrackSelection(positionUs, forceRecreateStreams,
return updatePeriodTrackSelection(positionUs, loadControl, forceRecreateStreams,
new boolean[renderers.length]); new boolean[renderers.length]);
} }
public long updatePeriodTrackSelection(long positionUs, LoadControl loadControl, public long updatePeriodTrackSelection(long positionUs, boolean forceRecreateStreams,
boolean forceRecreateStreams, boolean[] streamResetFlags) { boolean[] streamResetFlags) {
for (int i = 0; i < trackSelections.length; i++) { for (int i = 0; i < trackSelections.length; i++) {
mayRetainStreamFlags[i] = !forceRecreateStreams mayRetainStreamFlags[i] = !forceRecreateStreams
&& Util.areEqual(periodTrackSelections == null ? null : periodTrackSelections.get(i), && Util.areEqual(periodTrackSelections == null ? null : periodTrackSelections.get(i),
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment