com.google.android.exoplayer2.source.MediaPeriod Java Examples

private void maybeUpdateLoadingPeriod() throws IOException {
  queue.reevaluateBuffer(rendererPositionUs);
  if (queue.shouldLoadNextMediaPeriod()) {
    MediaPeriodInfo info = queue.getNextMediaPeriodInfo(rendererPositionUs, playbackInfo);
    if (info == null) {
      mediaSource.maybeThrowSourceInfoRefreshError();
    } else {
      Object uid = playbackInfo.timeline.getUidOfPeriod(info.id.periodIndex);
      MediaPeriod mediaPeriod =
          queue.enqueueNextMediaPeriod(
              rendererCapabilities,
              trackSelector,
              loadControl.getAllocator(),
              mediaSource,
              uid,
              info);
      mediaPeriod.prepare(this, info.startPositionUs);
      setIsLoading(true);
      updateLoadingMediaPeriodId();
    }
  }
}
 

@Override
public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator, long startPositionUs) {
  EventDispatcher eventDispatcher = createEventDispatcher(id);
  return new HlsMediaPeriod(
      extractorFactory,
      playlistTracker,
      dataSourceFactory,
      mediaTransferListener,
      drmSessionManager,
      loadErrorHandlingPolicy,
      eventDispatcher,
      allocator,
      compositeSequenceableLoaderFactory,
      allowChunklessPreparation,
      metadataType,
      useSessionKeys);
}
 

private void maybeUpdateLoadingPeriod() throws IOException {
  queue.reevaluateBuffer(rendererPositionUs);
  if (queue.shouldLoadNextMediaPeriod()) {
    MediaPeriodInfo info = queue.getNextMediaPeriodInfo(rendererPositionUs, playbackInfo);
    if (info == null) {
      maybeThrowSourceInfoRefreshError();
    } else {
      MediaPeriod mediaPeriod =
          queue.enqueueNextMediaPeriod(
              rendererCapabilities,
              trackSelector,
              loadControl.getAllocator(),
              mediaSource,
              info);
      mediaPeriod.prepare(this, info.startPositionUs);
      setIsLoading(true);
      handleLoadingMediaPeriodChanged(/* loadingTrackSelectionChanged= */ false);
    }
  }
}
 

@Override
public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator) {
  Assertions.checkArgument(id.periodIndex == 0);
  EventDispatcher eventDispatcher = createEventDispatcher(id);
  return new HlsMediaPeriod(
      extractorFactory,
      playlistTracker,
      dataSourceFactory,
      mediaTransferListener,
      chunkLoadErrorHandlingPolicy,
      minLoadableRetryCount,
      eventDispatcher,
      allocator,
      compositeSequenceableLoaderFactory,
      allowChunklessPreparation);
}
 

@Override
public MediaPeriod createPeriod(MediaPeriodId periodId, Allocator allocator) {
  int periodIndex = periodId.periodIndex;
  EventDispatcher periodEventDispatcher =
      createEventDispatcher(periodId, manifest.getPeriod(periodIndex).startMs);
  DashMediaPeriod mediaPeriod =
      new DashMediaPeriod(
          firstPeriodId + periodIndex,
          manifest,
          periodIndex,
          chunkSourceFactory,
          mediaTransferListener,
          minLoadableRetryCount,
          periodEventDispatcher,
          elapsedRealtimeOffsetMs,
          manifestLoadErrorThrower,
          allocator,
          compositeSequenceableLoaderFactory,
          playerEmsgCallback);
  periodsById.put(mediaPeriod.id, mediaPeriod);
  return mediaPeriod;
}
 

private void handlePeriodPrepared(MediaPeriod mediaPeriod) throws ExoPlaybackException {
  if (!queue.isLoading(mediaPeriod)) {
    // Stale event.
    return;
  }
  MediaPeriodHolder loadingPeriodHolder = queue.getLoadingPeriod();
  loadingPeriodHolder.handlePrepared(
      mediaClock.getPlaybackParameters().speed, playbackInfo.timeline);
  updateLoadControlTrackSelection(
      loadingPeriodHolder.getTrackGroups(), loadingPeriodHolder.getTrackSelectorResult());
  if (loadingPeriodHolder == queue.getPlayingPeriod()) {
    // This is the first prepared period, so update the position and the renderers.
    resetRendererPosition(loadingPeriodHolder.info.startPositionUs);
    updatePlayingPeriodRenderers(/* oldPlayingPeriodHolder= */ null);
  }
  maybeContinueLoading();
}
 

@Override
public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator, long startPositionUs) {
  EventDispatcher eventDispatcher = createEventDispatcher(id);
  return new HlsMediaPeriod(
      extractorFactory,
      playlistTracker,
      dataSourceFactory,
      mediaTransferListener,
      loadErrorHandlingPolicy,
      eventDispatcher,
      allocator,
      compositeSequenceableLoaderFactory,
      allowChunklessPreparation,
      metadataType,
      useSessionKeys);
}
 

private void handlePeriodPrepared(MediaPeriod mediaPeriod) throws ExoPlaybackException {
  if (!queue.isLoading(mediaPeriod)) {
    // Stale event.
    return;
  }
  MediaPeriodHolder loadingPeriodHolder = queue.getLoadingPeriod();
  loadingPeriodHolder.handlePrepared(mediaClock.getPlaybackParameters().speed);
  updateLoadControlTrackSelection(
      loadingPeriodHolder.trackGroups, loadingPeriodHolder.trackSelectorResult);
  if (!queue.hasPlayingPeriod()) {
    // This is the first prepared period, so start playing it.
    MediaPeriodHolder playingPeriodHolder = queue.advancePlayingPeriod();
    resetRendererPosition(playingPeriodHolder.info.startPositionUs);
    updatePlayingPeriodRenderers(/* oldPlayingPeriodHolder= */ null);
  }
  maybeContinueLoading();
}
 

@Override
public MediaPeriod createPeriod(
    MediaPeriodId periodId, Allocator allocator, long startPositionUs) {
  int periodIndex = (Integer) periodId.periodUid - firstPeriodId;
  EventDispatcher periodEventDispatcher =
      createEventDispatcher(periodId, manifest.getPeriod(periodIndex).startMs);
  DashMediaPeriod mediaPeriod =
      new DashMediaPeriod(
          firstPeriodId + periodIndex,
          manifest,
          periodIndex,
          chunkSourceFactory,
          mediaTransferListener,
          loadErrorHandlingPolicy,
          periodEventDispatcher,
          elapsedRealtimeOffsetMs,
          manifestLoadErrorThrower,
          allocator,
          compositeSequenceableLoaderFactory,
          playerEmsgCallback);
  periodsById.put(mediaPeriod.id, mediaPeriod);
  return mediaPeriod;
}
 

private void maybeUpdateLoadingPeriod() throws IOException {
  queue.reevaluateBuffer(rendererPositionUs);
  if (queue.shouldLoadNextMediaPeriod()) {
    MediaPeriodInfo info = queue.getNextMediaPeriodInfo(rendererPositionUs, playbackInfo);
    if (info == null) {
      maybeThrowSourceInfoRefreshError();
    } else {
      MediaPeriod mediaPeriod =
          queue.enqueueNextMediaPeriod(
              rendererCapabilities,
              trackSelector,
              loadControl.getAllocator(),
              mediaSource,
              info);
      mediaPeriod.prepare(this, info.startPositionUs);
      setIsLoading(true);
      handleLoadingMediaPeriodChanged(/* loadingTrackSelectionChanged= */ false);
    }
  }
}
 

@Override
public MediaPeriod createPeriod(
    MediaPeriodId periodId, Allocator allocator, long startPositionUs) {
  int periodIndex = (Integer) periodId.periodUid - firstPeriodId;
  EventDispatcher periodEventDispatcher =
      createEventDispatcher(periodId, manifest.getPeriod(periodIndex).startMs);
  DashMediaPeriod mediaPeriod =
      new DashMediaPeriod(
          firstPeriodId + periodIndex,
          manifest,
          periodIndex,
          chunkSourceFactory,
          mediaTransferListener,
          loadErrorHandlingPolicy,
          periodEventDispatcher,
          elapsedRealtimeOffsetMs,
          manifestLoadErrorThrower,
          allocator,
          compositeSequenceableLoaderFactory,
          playerEmsgCallback);
  periodsById.put(mediaPeriod.id, mediaPeriod);
  return mediaPeriod;
}
 

private void maybeUpdateLoadingPeriod() throws IOException {
  queue.reevaluateBuffer(rendererPositionUs);
  if (queue.shouldLoadNextMediaPeriod()) {
    MediaPeriodInfo info = queue.getNextMediaPeriodInfo(rendererPositionUs, playbackInfo);
    if (info == null) {
      mediaSource.maybeThrowSourceInfoRefreshError();
    } else {
      Object uid = playbackInfo.timeline.getUidOfPeriod(info.id.periodIndex);
      MediaPeriod mediaPeriod =
          queue.enqueueNextMediaPeriod(
              rendererCapabilities,
              trackSelector,
              loadControl.getAllocator(),
              mediaSource,
              uid,
              info);
      mediaPeriod.prepare(this, info.startPositionUs);
      setIsLoading(true);
      updateLoadingMediaPeriodId();
    }
  }
}
 

private void handlePeriodPrepared(MediaPeriod mediaPeriod) throws ExoPlaybackException {
  if (!queue.isLoading(mediaPeriod)) {
    // Stale event.
    return;
  }
  MediaPeriodHolder loadingPeriodHolder = queue.getLoadingPeriod();
  loadingPeriodHolder.handlePrepared(mediaClock.getPlaybackParameters().speed);
  updateLoadControlTrackSelection(
      loadingPeriodHolder.trackGroups, loadingPeriodHolder.trackSelectorResult);
  if (!queue.hasPlayingPeriod()) {
    // This is the first prepared period, so start playing it.
    MediaPeriodHolder playingPeriodHolder = queue.advancePlayingPeriod();
    resetRendererPosition(playingPeriodHolder.info.startPositionUs);
    updatePlayingPeriodRenderers(/* oldPlayingPeriodHolder= */ null);
  }
  maybeContinueLoading();
}
 

private void handlePeriodPrepared(MediaPeriod mediaPeriod) throws ExoPlaybackException {
  if (!queue.isLoading(mediaPeriod)) {
    // Stale event.
    return;
  }
  MediaPeriodHolder loadingPeriodHolder = queue.getLoadingPeriod();
  loadingPeriodHolder.handlePrepared(
      mediaClock.getPlaybackParameters().speed, playbackInfo.timeline);
  updateLoadControlTrackSelection(
      loadingPeriodHolder.getTrackGroups(), loadingPeriodHolder.getTrackSelectorResult());
  if (!queue.hasPlayingPeriod()) {
    // This is the first prepared period, so start playing it.
    MediaPeriodHolder playingPeriodHolder = queue.advancePlayingPeriod();
    resetRendererPosition(playingPeriodHolder.info.startPositionUs);
    updatePlayingPeriodRenderers(/* oldPlayingPeriodHolder= */ null);
  }
  maybeContinueLoading();
}
 

@Override
public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator) {
  Assertions.checkArgument(id.periodIndex == 0);
  EventDispatcher eventDispatcher = createEventDispatcher(id);
  return new HlsMediaPeriod(
      extractorFactory,
      playlistTracker,
      dataSourceFactory,
      mediaTransferListener,
      chunkLoadErrorHandlingPolicy,
      minLoadableRetryCount,
      eventDispatcher,
      allocator,
      compositeSequenceableLoaderFactory,
      allowChunklessPreparation);
}
 

@Override
public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator) {
  Assertions.checkArgument(id.periodIndex == 0);
  EventDispatcher eventDispatcher = createEventDispatcher(id);
  SsMediaPeriod period =
      new SsMediaPeriod(
          manifest,
          chunkSourceFactory,
          mediaTransferListener,
          compositeSequenceableLoaderFactory,
          minLoadableRetryCount,
          eventDispatcher,
          manifestLoaderErrorThrower,
          allocator);
  mediaPeriods.add(period);
  return period;
}
 

@Override
public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator, long startPositionUs) {
  EventDispatcher eventDispatcher = createEventDispatcher(id);
  SsMediaPeriod period =
      new SsMediaPeriod(
          manifest,
          chunkSourceFactory,
          mediaTransferListener,
          compositeSequenceableLoaderFactory,
          loadErrorHandlingPolicy,
          eventDispatcher,
          manifestLoaderErrorThrower,
          allocator);
  mediaPeriods.add(period);
  return period;
}
 

@Override
public MediaPeriod createPeriod(MediaPeriodId periodId, Allocator allocator) {
  int periodIndex = periodId.periodIndex;
  EventDispatcher periodEventDispatcher =
      createEventDispatcher(periodId, manifest.getPeriod(periodIndex).startMs);
  DashMediaPeriod mediaPeriod =
      new DashMediaPeriod(
          firstPeriodId + periodIndex,
          manifest,
          periodIndex,
          chunkSourceFactory,
          mediaTransferListener,
          minLoadableRetryCount,
          periodEventDispatcher,
          elapsedRealtimeOffsetMs,
          manifestLoadErrorThrower,
          allocator,
          compositeSequenceableLoaderFactory,
          playerEmsgCallback);
  periodsById.put(mediaPeriod.id, mediaPeriod);
  return mediaPeriod;
}
 

@Override
public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator, long startPositionUs) {
  EventDispatcher eventDispatcher = createEventDispatcher(id);
  return new HlsMediaPeriod(
      extractorFactory,
      playlistTracker,
      dataSourceFactory,
      mediaTransferListener,
      loadErrorHandlingPolicy,
      eventDispatcher,
      allocator,
      compositeSequenceableLoaderFactory,
      allowChunklessPreparation,
      metadataType,
      useSessionKeys);
}
 

/**
 * Enqueues a new media period based on the specified information as the new loading media period,
 * and returns it.
 *
 * @param rendererCapabilities The renderer capabilities.
 * @param trackSelector The track selector.
 * @param allocator The allocator.
 * @param mediaSource The media source that produced the media period.
 * @param uid The unique identifier for the containing timeline period.
 * @param info Information used to identify this media period in its timeline period.
 */
public MediaPeriod enqueueNextMediaPeriod(
    RendererCapabilities[] rendererCapabilities,
    TrackSelector trackSelector,
    Allocator allocator,
    MediaSource mediaSource,
    Object uid,
    MediaPeriodInfo info) {
  long rendererPositionOffsetUs =
      loading == null
          ? info.startPositionUs
          : (loading.getRendererOffset() + loading.info.durationUs);
  MediaPeriodHolder newPeriodHolder =
      new MediaPeriodHolder(
          rendererCapabilities,
          rendererPositionOffsetUs,
          trackSelector,
          allocator,
          mediaSource,
          uid,
          info);
  if (loading != null) {
    Assertions.checkState(hasPlayingPeriod());
    loading.next = newPeriodHolder;
  }
  oldFrontPeriodUid = null;
  loading = newPeriodHolder;
  length++;
  return newPeriodHolder.mediaPeriod;
}
 

@Override
public void releasePeriod(MediaPeriod mediaPeriod) {
  DeferredMediaPeriod deferredMediaPeriod = (DeferredMediaPeriod) mediaPeriod;
  List<DeferredMediaPeriod> mediaPeriods =
      deferredMediaPeriodByAdMediaSource.get(deferredMediaPeriod.mediaSource);
  if (mediaPeriods != null) {
    mediaPeriods.remove(deferredMediaPeriod);
  }
  deferredMediaPeriod.releasePeriod();
}
 

@Override
public MediaPeriod createPeriod(int index, Allocator allocator, long positionUs) {
  Assertions.checkArgument(index == 0);
  SsMediaPeriod period = new SsMediaPeriod(manifest, chunkSourceFactory, minLoadableRetryCount,
      eventDispatcher, manifestLoaderErrorThrower, allocator);
  mediaPeriods.add(period);
  return period;
}
 

/** Releases the given {@code mediaPeriod}, logging and suppressing any errors. */
private static void releaseMediaPeriod(
    long endPositionUs, MediaSource mediaSource, MediaPeriod mediaPeriod) {
  try {
    if (endPositionUs != C.TIME_UNSET && endPositionUs != C.TIME_END_OF_SOURCE) {
      mediaSource.releasePeriod(((ClippingMediaPeriod) mediaPeriod).mediaPeriod);
    } else {
      mediaSource.releasePeriod(mediaPeriod);
    }
  } catch (RuntimeException e) {
    // There's nothing we can do.
    Log.e(TAG, "Period release failed.", e);
  }
}
 

private void handleContinueLoadingRequested(MediaPeriod mediaPeriod) {
  if (!queue.isLoading(mediaPeriod)) {
    // Stale event.
    return;
  }
  queue.reevaluateBuffer(rendererPositionUs);
  maybeContinueLoading();
}
 

/** Releases the given {@code mediaPeriod}, logging and suppressing any errors. */
private static void releaseMediaPeriod(
    long endPositionUs, MediaSource mediaSource, MediaPeriod mediaPeriod) {
  try {
    if (endPositionUs != C.TIME_UNSET && endPositionUs != C.TIME_END_OF_SOURCE) {
      mediaSource.releasePeriod(((ClippingMediaPeriod) mediaPeriod).mediaPeriod);
    } else {
      mediaSource.releasePeriod(mediaPeriod);
    }
  } catch (RuntimeException e) {
    // There's nothing we can do.
    Log.e(TAG, "Period release failed.", e);
  }
}
 

@Override
public void releasePeriod(MediaPeriod mediaPeriod) {
  DeferredMediaPeriod deferredMediaPeriod = (DeferredMediaPeriod) mediaPeriod;
  List<DeferredMediaPeriod> mediaPeriods =
      deferredMediaPeriodByAdMediaSource.get(deferredMediaPeriod.mediaSource);
  if (mediaPeriods != null) {
    mediaPeriods.remove(deferredMediaPeriod);
  }
  deferredMediaPeriod.releasePeriod();
}
 

private void handlePeriodPrepared(MediaPeriod period) throws ExoPlaybackException {
  if (loadingPeriodHolder == null || loadingPeriodHolder.mediaPeriod != period) {
    // Stale event.
    return;
  }
  loadingPeriodHolder.handlePrepared();
  if (playingPeriodHolder == null) {
    // This is the first prepared period, so start playing it.
    readingPeriodHolder = loadingPeriodHolder;
    resetRendererPosition(readingPeriodHolder.startPositionUs);
    setPlayingPeriodHolder(readingPeriodHolder);
  }
  maybeContinueLoading();
}
 

private void handleContinueLoadingRequested(MediaPeriod period) {
  if (loadingPeriodHolder == null || loadingPeriodHolder.mediaPeriod != period) {
    // Stale event.
    return;
  }
  maybeContinueLoading();
}
 

@Override
public MediaPeriod createPeriod(int periodIndex, Allocator allocator, long positionUs) {
  EventDispatcher periodEventDispatcher = eventDispatcher.copyWithMediaTimeOffsetMs(
      manifest.getPeriod(periodIndex).startMs);
  DashMediaPeriod mediaPeriod = new DashMediaPeriod(firstPeriodId + periodIndex, manifest,
      periodIndex, chunkSourceFactory, minLoadableRetryCount, periodEventDispatcher,
      elapsedRealtimeOffsetMs, loaderErrorThrower, allocator);
  periodsById.put(mediaPeriod.id, mediaPeriod);
  return mediaPeriod;
}
 

/**
 * Enqueues a new media period based on the specified information as the new loading media period,
 * and returns it.
 *
 * @param rendererCapabilities The renderer capabilities.
 * @param trackSelector The track selector.
 * @param allocator The allocator.
 * @param mediaSource The media source that produced the media period.
 * @param info Information used to identify this media period in its timeline period.
 */
public MediaPeriod enqueueNextMediaPeriod(
    RendererCapabilities[] rendererCapabilities,
    TrackSelector trackSelector,
    Allocator allocator,
    MediaSource mediaSource,
    MediaPeriodInfo info) {
  long rendererPositionOffsetUs =
      loading == null
          ? (info.id.isAd() && info.contentPositionUs != C.TIME_UNSET
              ? info.contentPositionUs
              : 0)
          : (loading.getRendererOffset() + loading.info.durationUs - info.startPositionUs);
  MediaPeriodHolder newPeriodHolder =
      new MediaPeriodHolder(
          rendererCapabilities,
          rendererPositionOffsetUs,
          trackSelector,
          allocator,
          mediaSource,
          info);
  if (loading != null) {
    Assertions.checkState(hasPlayingPeriod());
    loading.setNext(newPeriodHolder);
  }
  oldFrontPeriodUid = null;
  loading = newPeriodHolder;
  length++;
  return newPeriodHolder.mediaPeriod;
}