라이브 영상의 DVR 윈도우란 무엇인가#

1// dash/dash_parser.js — parseManifest 과정 (발췌)
2let segmentAvailabilityDuration = TXml.parseAttr(
3    mpd, 'timeShiftBufferDepth', TXml.parseDuration);

1// hls/hls_parser.js (발췌)
2// The spec says nothing much about seeking in live content, but Safari's
3// built-in HLS implementation does not allow it.  Therefore we will set
4// the availability window equal to the presentation delay.  The player
5// will be able to buffer ahead three segments, but the seek window will
6// be zero-sized.
7let segmentAvailabilityDuration = this.getLiveDuration_() || 0;
8
9// The app can override that with a longer duration, to allow seeking.
10if (!isNaN(this.config_.availabilityWindowOverride)) {
11  segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
12}
13
14this.presentationTimeline_.setSegmentAvailabilityDuration(
15    segmentAvailabilityDuration);

1// media/presentation_timeline.js (발췌)
2getSegmentAvailabilityStart() {
3  const end = this.getSegmentAvailabilityEnd();
4  const start = end - this.segmentAvailabilityDuration_;
5  return Math.max(this.userSeekStart_, start);
6}
7
8getSegmentAvailabilityEnd() {
9  // ... 정적 매니페스트 처리 생략 ...
10  // Can be either live or "in-progress recording" (live with known duration)
11  return Math.min(this.getLiveEdge_() + this.availabilityTimeOffset_,
12      this.duration_);
13}

1// media/presentation_timeline.js (발췌)
2getSeekRangeStart() {
3  return this.getSafeSeekRangeStart(/* offset= */ 0);
4}
5
6getSeekRangeEnd() {
7  const useDelay = this.isDynamic();
8  const delay = useDelay ? this.presentationDelay_ : 0;
9  return Math.max(0, this.getSegmentAvailabilityEnd() - delay);
10}

1// player.js — seekRange() (발췌)
2const timeline = this.manifest_.presentationTimeline;
3
4return {
5  'start': timeline.getSeekRangeStart(),
6  'end': timeline.getSeekRangeEnd(),
7};

1// media/playhead.js — ready() (발췌)
2ready() {
3  this.checkWindowTimer_.tickEvery(/* seconds= */ 0.25);
4}

1// media/playhead.js — onPollWindow_
2onPollWindow_() {
3  // Don't catch up to the seek range when we are paused or empty.
4  if (this.mediaElement_.readyState == 0 || this.mediaElement_.paused) {
5    return;
6  }
7
8  const currentTime = this.videoWrapper_.getTime();
9  let seekStart = this.timeline_.getSeekRangeStart();
10  const seekEnd = this.timeline_.getSeekRangeEnd();
11
12  if (seekEnd - seekStart < this.minSeekRange_) {
13    seekStart = seekEnd - this.minSeekRange_;
14  }
15
16  if (currentTime < seekStart) {
17    // The seek range has moved past the playhead.  Move ahead to catch up.
18    const targetTime = this.reposition_(currentTime);
19    shaka.log.info('Jumping forward ' + (targetTime - currentTime) +
20                   ' seconds to catch up with the seek range.');
21    this.mediaElement_.currentTime = targetTime;
22  }
23}

1// media/playhead.js — 필드 선언 (발췌)
2/**
3 * The seek range must be at least this number of seconds long. If it is
4 * smaller than this, change it to be this big so we don't repeatedly seek
5 * to keep within a zero-width window.
6 *
7 * This is 3s long, to account for the weaker hardware on platforms like
8 * Chromecast.
9 */
10this.minSeekRange_ = 3.0;

1// media/playhead.js — reposition_ (발췌)
2const rebufferingGoal = this.config_.rebufferingGoal;
3const safeSeekOffset = this.config_.safeSeekOffset;
4
5let start = this.timeline_.getSeekRangeStart();
6const end = this.timeline_.getSeekRangeEnd();
7const duration = this.timeline_.getDuration();
8
9if (end - start < this.minSeekRange_) {
10  start = end - this.minSeekRange_;
11}
12
13// With live content, the beginning of the availability window is moving
14// forward.  This means we cannot seek to it since we will "fall" outside
15// the window while we buffer.  So we define a "safe" region that is far
16// enough away.  For VOD, |safe == start|.
17const safe = this.timeline_.getSafeSeekRangeStart(rebufferingGoal);
18
19// These are the times to seek to rather than the exact destinations.  When
20// we seek, we will get another event (after a slight delay) and these steps
21// will run again.  So if we seeked directly to |start|, |start| would move
22// on the next call and we would loop forever.
23const seekStart = this.timeline_.getSafeSeekRangeStart(safeSeekOffset);
24const seekSafe = this.timeline_.getSafeSeekRangeStart(
25    rebufferingGoal + safeSeekOffset);

1// media/playhead.js — reposition_ (발췌)
2if (currentTime >= duration) {
3  return this.clampSeekToDuration_(currentTime);
4}
5
6if (currentTime > end) {
7  // We remove the safeSeekEndOffset of the seek end to avoid the player
8  // to be block at the edge in a live stream
9  return end - this.config_.safeSeekEndOffset;
10}
11
12if (currentTime < start) {
13  if (this.timeline_.isLive() &&
14      this.config_.returnToEndOfLiveWindowWhenOutside) {
15    return end - this.config_.safeSeekEndOffset;
16  }
17  if (isBuffered(seekStart)) {
18    return seekStart;
19  } else {
20    return seekSafe;
21  }
22}
23
24if (currentTime >= safe || isBuffered(currentTime)) {
25  return currentTime;
26} else {
27  return seekSafe;
28}

1// util/player_configuration.js (발췌)
2safeSeekOffset: 5,
3safeSeekEndOffset: 0,
4returnToEndOfLiveWindowWhenOutside: false,

1// media/playhead.js — onPollWindow_ (발췌)
2// Don't catch up to the seek range when we are paused or empty.
3if (this.mediaElement_.readyState == 0 || this.mediaElement_.paused) {
4  return;
5}

1// 재생 재개 시점에 라이브 엣지 근처로 재조정하는 예시
2const LIVE_EDGE_MARGIN = 3; // 엣지 끝자락은 피한다
3
4video.addEventListener('play', () => {
5  if (!player.isLive()) return;
6
7  const { start, end } = player.seekRange();
8  const target = Math.max(start, end - LIVE_EDGE_MARGIN);
9
10  if (video.currentTime < start || video.currentTime > target) {
11    video.currentTime = target;
12  }
13});