Java C.TIME_END_OF_SOURCE属性代码示例

@Override
public void onPositionDiscontinuity(@Player.DiscontinuityReason int reason) {
  if (adsManager == null) {
    return;
  }
  if (!playingAd && !player.isPlayingAd()) {
    checkForContentComplete();
    if (sentContentComplete) {
      for (int i = 0; i < adPlaybackState.adGroupCount; i++) {
        if (adPlaybackState.adGroupTimesUs[i] != C.TIME_END_OF_SOURCE) {
          adPlaybackState.playedAdGroup(i);
        }
      }
      updateAdPlaybackState();
    } else {
      long positionMs = player.getCurrentPosition();
      timeline.getPeriod(0, period);
      if (period.getAdGroupIndexForPositionUs(C.msToUs(positionMs)) != C.INDEX_UNSET) {
        sentPendingContentPositionMs = false;
        pendingContentPositionMs = positionMs;
      }
    }
  } else {
    updateImaStateForPlayerState();
  }
}
 

private void updateImaStateForPlayerState() {
  boolean wasPlayingAd = playingAd;
  playingAd = player.isPlayingAd();
  if (!sentContentComplete) {
    boolean adFinished = (wasPlayingAd && !playingAd)
        || playingAdIndexInAdGroup != player.getCurrentAdIndexInAdGroup();
    if (adFinished) {
      // IMA is waiting for the ad playback to finish so invoke the callback now.
      // Either CONTENT_RESUME_REQUESTED will be passed next, or playAd will be called again.
      for (int i = 0; i < adCallbacks.size(); i++) {
        adCallbacks.get(i).onEnded();
      }
    }
    if (!wasPlayingAd && playingAd) {
      int adGroupIndex = player.getCurrentAdGroupIndex();
      // IMA hasn't sent CONTENT_PAUSE_REQUESTED yet, so fake the content position.
      fakeContentProgressElapsedRealtimeMs = SystemClock.elapsedRealtime();
      fakeContentProgressOffsetMs = C.usToMs(adPlaybackState.adGroupTimesUs[adGroupIndex]);
      if (fakeContentProgressOffsetMs == C.TIME_END_OF_SOURCE) {
        fakeContentProgressOffsetMs = contentDurationMs;
      }
    }
  }
  playingAdIndexInAdGroup = playingAd ? player.getCurrentAdIndexInAdGroup() : C.INDEX_UNSET;
}
 

public long getBufferedPositionUs() {
  if (loadingFinished) {
    return C.TIME_END_OF_SOURCE;
  } else if (isPendingReset()) {
    return pendingResetPositionUs;
  } else {
    long bufferedPositionUs = lastSeekPositionUs;
    HlsMediaChunk lastMediaChunk = mediaChunks.getLast();
    HlsMediaChunk lastCompletedMediaChunk = lastMediaChunk.isLoadCompleted() ? lastMediaChunk
        : mediaChunks.size() > 1 ? mediaChunks.get(mediaChunks.size() - 2) : null;
    if (lastCompletedMediaChunk != null) {
      bufferedPositionUs = Math.max(bufferedPositionUs, lastCompletedMediaChunk.endTimeUs);
    }
    int sampleQueueCount = sampleQueues.size();
    for (int i = 0; i < sampleQueueCount; i++) {
      bufferedPositionUs = Math.max(bufferedPositionUs,
          sampleQueues.valueAt(i).getLargestQueuedTimestampUs());
    }
    return bufferedPositionUs;
  }
}
 

/**
 * Creates a new clipping timeline that wraps the specified timeline.
 *
 * @param timeline The timeline to clip.
 * @param startUs The number of microseconds to clip from the start of {@code timeline}.
 * @param endUs The end position in microseconds for the clipped timeline relative to the start
 *     of {@code timeline}, or {@link C#TIME_END_OF_SOURCE} to clip no samples from the end.
 */
public ClippingTimeline(Timeline timeline, long startUs, long endUs) {
  Assertions.checkArgument(timeline.getWindowCount() == 1);
  Assertions.checkArgument(timeline.getPeriodCount() == 1);
  Window window = timeline.getWindow(0, new Window(), false);
  Assertions.checkArgument(!window.isDynamic);
  long resolvedEndUs = endUs == C.TIME_END_OF_SOURCE ? window.durationUs : endUs;
  if (window.durationUs != C.TIME_UNSET) {
    Assertions.checkArgument(startUs == 0 || window.isSeekable);
    Assertions.checkArgument(resolvedEndUs <= window.durationUs);
    Assertions.checkArgument(startUs <= resolvedEndUs);
  }
  Period period = timeline.getPeriod(0, new Period());
  Assertions.checkArgument(period.getPositionInWindowUs() == 0);
  this.timeline = timeline;
  this.startUs = startUs;
  this.endUs = resolvedEndUs;
}
 

@Override
public int readData(FormatHolder formatHolder, DecoderInputBuffer buffer,
    boolean requireFormat) {
  if (pendingDiscontinuity) {
    return C.RESULT_NOTHING_READ;
  }
  if (sentEos) {
    buffer.setFlags(C.BUFFER_FLAG_END_OF_STREAM);
    return C.RESULT_BUFFER_READ;
  }
  int result = stream.readData(formatHolder, buffer, requireFormat);
  // TODO: Clear gapless playback metadata if a format was read (if applicable).
  if (endUs != C.TIME_END_OF_SOURCE && ((result == C.RESULT_BUFFER_READ
      && buffer.timeUs >= endUs) || (result == C.RESULT_NOTHING_READ
      && mediaPeriod.getBufferedPositionUs() == C.TIME_END_OF_SOURCE))) {
    buffer.clear();
    buffer.setFlags(C.BUFFER_FLAG_END_OF_STREAM);
    sentEos = true;
    return C.RESULT_BUFFER_READ;
  }
  if (result == C.RESULT_BUFFER_READ && !buffer.isEndOfStream()) {
    buffer.timeUs -= startUs;
  }
  return result;
}
 

@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.size();
    for (int i = 0; i < trackCount; i++) {
      if (trackIsAudioVideoFlags[i]) {
        largestQueuedTimestampUs = Math.min(largestQueuedTimestampUs,
            sampleQueues.valueAt(i).getLargestQueuedTimestampUs());
      }
    }
  } else {
    largestQueuedTimestampUs = getLargestQueuedTimestampUs();
  }
  return largestQueuedTimestampUs == Long.MIN_VALUE ? lastSeekPositionUs
      : largestQueuedTimestampUs;
}
 

/**
 * 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());
  }
}
 

@Override
public boolean continueLoading(long positionUs) {
  boolean madeProgress = false;
  boolean madeProgressThisIteration;
  do {
    madeProgressThisIteration = false;
    long nextLoadPositionUs = getNextLoadPositionUs();
    if (nextLoadPositionUs == C.TIME_END_OF_SOURCE) {
      break;
    }
    for (SequenceableLoader loader : loaders) {
      if (loader.getNextLoadPositionUs() == nextLoadPositionUs) {
        madeProgressThisIteration |= loader.continueLoading(positionUs);
      }
    }
    madeProgress |= madeProgressThisIteration;
  } while (madeProgressThisIteration);
  return madeProgress;
}
 

private static long[] getAdGroupTimesUs(List<Float> cuePoints) {
  if (cuePoints.isEmpty()) {
    // If no cue points are specified, there is a preroll ad.
    return new long[] {0};
  }

  int count = cuePoints.size();
  long[] adGroupTimesUs = new long[count];
  for (int i = 0; i < count; i++) {
    double cuePoint = cuePoints.get(i);
    adGroupTimesUs[i] =
        cuePoint == -1.0 ? C.TIME_END_OF_SOURCE : (long) (C.MICROS_PER_SECOND * cuePoint);
  }
  return adGroupTimesUs;
}
 

@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
public long getNextLoadPositionUs() {
  if (isPendingReset()) {
    return pendingResetPositionUs;
  } else {
    return loadingFinished ? C.TIME_END_OF_SOURCE : mediaChunks.getLast().endTimeUs;
  }
}
 

@Override
public void onSourceInfoRefreshed(Timeline timeline, Object manifest) {
  clippingTimeline = new ClippingTimeline(timeline, startUs, endUs);
  sourceListener.onSourceInfoRefreshed(clippingTimeline, manifest);
  long startUs = clippingTimeline.startUs;
  long endUs = clippingTimeline.endUs == C.TIME_UNSET ? C.TIME_END_OF_SOURCE
      : clippingTimeline.endUs;
  int count = mediaPeriods.size();
  for (int i = 0; i < count; i++) {
    mediaPeriods.get(i).setClipping(startUs, endUs);
  }
}
 

@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 Math.max(0, bufferedPositionUs - startUs);
}
 

@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 - startUs;
}
 

@Override
public long getNextLoadPositionUs() {
  long nextLoadPositionUs = Long.MAX_VALUE;
  for (SequenceableLoader loader : loaders) {
    long loaderNextLoadPositionUs = loader.getNextLoadPositionUs();
    if (loaderNextLoadPositionUs != C.TIME_END_OF_SOURCE) {
      nextLoadPositionUs = Math.min(nextLoadPositionUs, loaderNextLoadPositionUs);
    }
  }
  return nextLoadPositionUs == Long.MAX_VALUE ? C.TIME_END_OF_SOURCE : nextLoadPositionUs;
}