Java Code Examples for com.google.android.exoplayer2.C#TIME_END_OF_SOURCE

@Override
public long getBufferedPositionUs() {
  if (loadingFinished) {
    return C.TIME_END_OF_SOURCE;
  } else if (isPendingReset()) {
    return pendingResetPositionUs;
  } else {
    long bufferedPositionUs = lastSeekPositionUs;
    HlsMediaChunk lastMediaChunk = getLastMediaChunk();
    HlsMediaChunk lastCompletedMediaChunk = lastMediaChunk.isLoadCompleted() ? lastMediaChunk
        : mediaChunks.size() > 1 ? mediaChunks.get(mediaChunks.size() - 2) : null;
    if (lastCompletedMediaChunk != null) {
      bufferedPositionUs = Math.max(bufferedPositionUs, lastCompletedMediaChunk.endTimeUs);
    }
    if (sampleQueuesBuilt) {
      for (SampleQueue sampleQueue : sampleQueues) {
        bufferedPositionUs =
            Math.max(bufferedPositionUs, sampleQueue.getLargestQueuedTimestampUs());
      }
    }
    return bufferedPositionUs;
  }
}
 

@Override
public long getBufferedPositionUs() {
  if (loadingFinished) {
    return C.TIME_END_OF_SOURCE;
  } else if (isPendingReset()) {
    return pendingResetPositionUs;
  }
  long largestQueuedTimestampUs;
  if (haveAudioVideoTracks) {
    // Ignore non-AV tracks, which may be sparse or poorly interleaved.
    largestQueuedTimestampUs = Long.MAX_VALUE;
    int trackCount = sampleQueues.length;
    for (int i = 0; i < trackCount; i++) {
      if (trackIsAudioVideoFlags[i]) {
        largestQueuedTimestampUs = Math.min(largestQueuedTimestampUs,
            sampleQueues[i].getLargestQueuedTimestampUs());
      }
    }
  } else {
    largestQueuedTimestampUs = getLargestQueuedTimestampUs();
  }
  return largestQueuedTimestampUs == Long.MIN_VALUE ? lastSeekPositionUs
      : largestQueuedTimestampUs;
}
 

/**
 * Returns the index of the next ad group after {@code positionUs} that has ads remaining to be
 * played. Returns {@link C#INDEX_UNSET} if there is no such ad group.
 *
 * @param positionUs The position after which to find an ad group, in microseconds, or {@link
 *     C#TIME_END_OF_SOURCE} for the end of the stream (in which case there can be no ad group
 *     after the position).
 * @param periodDurationUs The duration of the containing period in microseconds, or {@link
 *     C#TIME_UNSET} if not known.
 * @return The index of the ad group, or {@link C#INDEX_UNSET}.
 */
public int getAdGroupIndexAfterPositionUs(long positionUs, long periodDurationUs) {
  if (positionUs == C.TIME_END_OF_SOURCE
      || (periodDurationUs != C.TIME_UNSET && positionUs >= periodDurationUs)) {
    return C.INDEX_UNSET;
  }
  // Use a linear search as the array elements may not be increasing due to TIME_END_OF_SOURCE.
  // In practice we expect there to be few ad groups so the search shouldn't be expensive.
  int index = 0;
  while (index < adGroupTimesUs.length
      && adGroupTimesUs[index] != C.TIME_END_OF_SOURCE
      && (positionUs >= adGroupTimesUs[index] || !adGroups[index].hasUnplayedAds())) {
    index++;
  }
  return index < adGroupTimesUs.length ? index : C.INDEX_UNSET;
}
 

/**
 * Returns an estimate of the position up to which data is buffered.
 *
 * @return An estimate of the absolute position in microseconds up to which data is buffered, or
 *     {@link C#TIME_END_OF_SOURCE} if the track is fully buffered.
 */
public long getBufferedPositionUs() {
  if (loadingFinished) {
    return C.TIME_END_OF_SOURCE;
  } else if (isPendingReset()) {
    return pendingResetPositionUs;
  } else {
    long bufferedPositionUs = lastSeekPositionUs;
    BaseMediaChunk lastMediaChunk = mediaChunks.getLast();
    BaseMediaChunk lastCompletedMediaChunk = lastMediaChunk.isLoadCompleted() ? lastMediaChunk
        : mediaChunks.size() > 1 ? mediaChunks.get(mediaChunks.size() - 2) : null;
    if (lastCompletedMediaChunk != null) {
      bufferedPositionUs = Math.max(bufferedPositionUs, lastCompletedMediaChunk.endTimeUs);
    }
    return Math.max(bufferedPositionUs, primarySampleQueue.getLargestQueuedTimestampUs());
  }
}
 

private boolean isPositionBeforeAdGroup(long positionUs, int adGroupIndex) {
  if (positionUs == C.TIME_END_OF_SOURCE) {
    // The end of the content is at (but not before) any postroll ad, and after any other ads.
    return false;
  }
  long adGroupPositionUs = adGroupTimesUs[adGroupIndex];
  if (adGroupPositionUs == C.TIME_END_OF_SOURCE) {
    return contentDurationUs == C.TIME_UNSET || positionUs < contentDurationUs;
  } else {
    return positionUs < adGroupPositionUs;
  }
}
 

@Override
public long getNextLoadPositionUs() {
  if (isPendingReset()) {
    return pendingResetPositionUs;
  } else {
    return loadingFinished ? C.TIME_END_OF_SOURCE : getLastMediaChunk().endTimeUs;
  }
}
 

/**
 * Returns the index of the ad group at or before {@code positionUs}, if that ad group is
 * unplayed. Returns {@link C#INDEX_UNSET} if the ad group at or before {@code positionUs} has no
 * ads remaining to be played, or if there is no such ad group.
 *
 * @param positionUs The position at or before which to find an ad group, in microseconds.
 * @return The index of the ad group, or {@link C#INDEX_UNSET}.
 */
public int getAdGroupIndexForPositionUs(long positionUs) {
  // Use a linear search as the array elements may not be increasing due to TIME_END_OF_SOURCE.
  // In practice we expect there to be few ad groups so the search shouldn't be expensive.
  int index = adGroupTimesUs.length - 1;
  while (index >= 0
      && (adGroupTimesUs[index] == C.TIME_END_OF_SOURCE || adGroupTimesUs[index] > positionUs)) {
    index--;
  }
  return index >= 0 && adGroups[index].hasUnplayedAds() ? index : C.INDEX_UNSET;
}
 

@Override
protected long getMediaTimeForChildMediaTime(Void id, long mediaTimeMs) {
  if (mediaTimeMs == C.TIME_UNSET) {
    return C.TIME_UNSET;
  }
  long startMs = C.usToMs(startUs);
  long clippedTimeMs = Math.max(0, mediaTimeMs - startMs);
  if (endUs != C.TIME_END_OF_SOURCE) {
    clippedTimeMs = Math.min(C.usToMs(endUs) - startMs, clippedTimeMs);
  }
  return clippedTimeMs;
}
 

/**
 * Returns the index of the next ad group after {@code positionUs} that has ads remaining to be
 * played. Returns {@link C#INDEX_UNSET} if there is no such ad group.
 *
 * @param positionUs The position after which to find an ad group, in microseconds.
 * @return The index of the ad group, or {@link C#INDEX_UNSET}.
 */
public int getAdGroupIndexAfterPositionUs(long positionUs) {
  // Use a linear search as the array elements may not be increasing due to TIME_END_OF_SOURCE.
  // In practice we expect there to be few ad groups so the search shouldn't be expensive.
  int index = 0;
  while (index < adGroupTimesUs.length
      && adGroupTimesUs[index] != C.TIME_END_OF_SOURCE
      && (positionUs >= adGroupTimesUs[index] || !adGroups[index].hasUnplayedAds())) {
    index++;
  }
  return index < adGroupTimesUs.length ? index : C.INDEX_UNSET;
}
 

private boolean isPositionBeforeAdGroup(long positionUs, int adGroupIndex) {
  if (positionUs == C.TIME_END_OF_SOURCE) {
    // The end of the content is at (but not before) any postroll ad, and after any other ads.
    return false;
  }
  long adGroupPositionUs = adGroupTimesUs[adGroupIndex];
  if (adGroupPositionUs == C.TIME_END_OF_SOURCE) {
    return contentDurationUs == C.TIME_UNSET || positionUs < contentDurationUs;
  } else {
    return positionUs < adGroupPositionUs;
  }
}
 

@Override
public long getNextLoadPositionUs() {
  if (isPendingReset()) {
    return pendingResetPositionUs;
  } else {
    return loadingFinished ? C.TIME_END_OF_SOURCE : getLastMediaChunk().endTimeUs;
  }
}
 

@Override
public long getNextLoadPositionUs() {
  long nextLoadPositionUs = mediaPeriod.getNextLoadPositionUs();
  if (nextLoadPositionUs == C.TIME_END_OF_SOURCE
      || (endUs != C.TIME_END_OF_SOURCE && nextLoadPositionUs >= endUs)) {
    return C.TIME_END_OF_SOURCE;
  }
  return nextLoadPositionUs;
}
 

@Override
public long getBufferedPositionUs() {
  long bufferedPositionUs = Long.MAX_VALUE;
  for (HlsSampleStreamWrapper sampleStreamWrapper : enabledSampleStreamWrappers) {
    long rendererBufferedPositionUs = sampleStreamWrapper.getBufferedPositionUs();
    if (rendererBufferedPositionUs != C.TIME_END_OF_SOURCE) {
      bufferedPositionUs = Math.min(bufferedPositionUs, rendererBufferedPositionUs);
    }
  }
  return bufferedPositionUs == Long.MAX_VALUE ? C.TIME_END_OF_SOURCE : bufferedPositionUs;
}
 

@Override
protected long getMediaTimeForChildMediaTime(Void id, long mediaTimeMs) {
  if (mediaTimeMs == C.TIME_UNSET) {
    return C.TIME_UNSET;
  }
  long startMs = C.usToMs(startUs);
  long clippedTimeMs = Math.max(0, mediaTimeMs - startMs);
  if (endUs != C.TIME_END_OF_SOURCE) {
    clippedTimeMs = Math.min(C.usToMs(endUs) - startMs, clippedTimeMs);
  }
  return clippedTimeMs;
}
 

/**
 * Returns the index of the next ad group after {@code positionUs} that has ads remaining to be
 * played. Returns {@link C#INDEX_UNSET} if there is no such ad group.
 *
 * @param positionUs The position after which to find an ad group, in microseconds.
 * @return The index of the ad group, or {@link C#INDEX_UNSET}.
 */
public int getAdGroupIndexAfterPositionUs(long positionUs) {
  // Use a linear search as the array elements may not be increasing due to TIME_END_OF_SOURCE.
  // In practice we expect there to be few ad groups so the search shouldn't be expensive.
  int index = 0;
  while (index < adGroupTimesUs.length
      && adGroupTimesUs[index] != C.TIME_END_OF_SOURCE
      && (positionUs >= adGroupTimesUs[index] || !adGroups[index].hasUnplayedAds())) {
    index++;
  }
  return index < adGroupTimesUs.length ? index : C.INDEX_UNSET;
}
 

@Override
public long getBufferedPositionUs() {
  long bufferedPositionUs = mediaPeriod.getBufferedPositionUs();
  if (bufferedPositionUs == C.TIME_END_OF_SOURCE
      || (endUs != C.TIME_END_OF_SOURCE && bufferedPositionUs >= endUs)) {
    return C.TIME_END_OF_SOURCE;
  }
  return bufferedPositionUs;
}
 

@Override
public long getBufferedPositionUs() {
  long bufferedPositionUs = Long.MAX_VALUE;
  for (MediaPeriod period : enabledPeriods) {
    long rendererBufferedPositionUs = period.getBufferedPositionUs();
    if (rendererBufferedPositionUs != C.TIME_END_OF_SOURCE) {
      bufferedPositionUs = Math.min(bufferedPositionUs, rendererBufferedPositionUs);
    }
  }
  return bufferedPositionUs == Long.MAX_VALUE ? C.TIME_END_OF_SOURCE : bufferedPositionUs;
}
 

@Override
public long getNextLoadPositionUs() {
  return enabledTrackCount == 0 ? C.TIME_END_OF_SOURCE : getBufferedPositionUs();
}
 

@Override
public long getNextLoadPositionUs() {
  return loadingFinished || loader.isLoading() ? C.TIME_END_OF_SOURCE : 0;
}
 

@Override
public long getBufferedPositionUs() {
  return C.TIME_END_OF_SOURCE;
}