shaka-player 3.1.0 → 3.1.4

package/test/dash/dash_parser_manifest_unit.js

@@ -38,6 +38,14 @@ describe('DashParser Manifest', () => {
 
   /** @type {!string} */
   const thumbnailScheme = 'http://dashif.org/guidelines/thumbnail_tile';
+  /**
+   * CICP scheme. parameter must be one of the following: "ColourPrimaries",
+   * "TransferCharacteristics", or "MatrixCoefficients".
+   *
+   * @param {string} parameter
+   * @return {string}
+   */
+  const cicpScheme = (parameter) => `urn:mpeg:mpegB:cicp:${parameter}`;
 
   beforeAll(async () => {
     mp4Index = await shaka.test.Util.fetch(mp4IndexSegmentUri);
@@ -1854,7 +1862,8 @@ describe('DashParser Manifest', () => {
     expect(textStream.forced).toBe(true);
   });
 
-  it('supports HDR signaling', async () => {
+  it('supports HDR signaling via profiles', async () => {
+    // (DASH-IF IOP v4.3 10.3.3.)
     const hdrProfile =
         'http://dashif.org/guidelines/dash-if-uhd#hevc-hdr-pq10';
     const manifestText = [
@@ -1885,6 +1894,110 @@ describe('DashParser Manifest', () => {
     expect(stream.hdr).toBe('PQ');
   });
 
+  it('supports HDR signaling via SupplementalProperty', async () => {
+    // (DASH-IF IOP v4.3 6.2.5.1.)
+    const hdrScheme = cicpScheme('TransferCharacteristics');
+    const pq = 16;
+    const manifestText = [
+      '<MPD minBufferTime="PT75S">',
+      '  <Period id="1" duration="PT30S">',
+      '    <AdaptationSet id="2" mimeType="video/mp4">',
+      `      <SupplementalProperty schemeIdUri="${hdrScheme}" value="${pq}" />`,
+      '      <Representation codecs="hvc1.2.4.L150.90">',
+      '        <BaseURL>v-sd.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '    <AdaptationSet id="3" mimeType="audio/mp4">',
+      '      <Representation id="audio-en">',
+      '        <BaseURL>a-en.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '  </Period>',
+      '</MPD>',
+    ].join('\n');
+
+    fakeNetEngine.setResponseText('dummy://foo', manifestText);
+
+    /** @type {shaka.extern.Manifest} */
+    const manifest = await parser.start('dummy://foo', playerInterface);
+    expect(manifest.variants.length).toBe(1);
+    const stream = manifest.variants[0].video;
+    expect(stream.hdr).toBe('PQ');
+  });
+
+  it('supports HDR signaling via EssentialProperty', async () => {
+    // (DASH-IF IOP v4.3 6.2.5.1.)
+    const hdrScheme = cicpScheme('TransferCharacteristics');
+    const hlg = 18;
+    const manifestText = [
+      '<MPD minBufferTime="PT75S">',
+      '  <Period id="1" duration="PT30S">',
+      '    <AdaptationSet id="2" mimeType="video/mp4">',
+      `      <EssentialProperty schemeIdUri="${hdrScheme}" value="${hlg}" />`,
+      '      <Representation codecs="hvc1.2.4.L153.B0">',
+      '        <BaseURL>v-sd.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '    <AdaptationSet id="3" mimeType="audio/mp4">',
+      '      <Representation id="audio-en">',
+      '        <BaseURL>a-en.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '  </Period>',
+      '</MPD>',
+    ].join('\n');
+
+    fakeNetEngine.setResponseText('dummy://foo', manifestText);
+
+    /** @type {shaka.extern.Manifest} */
+    const manifest = await parser.start('dummy://foo', playerInterface);
+    expect(manifest.variants.length).toBe(1);
+    const stream = manifest.variants[0].video;
+    expect(stream.hdr).toBe('HLG');
+  });
+
+  it('supports SDR signalling via EssentialProperty', async () => {
+    // (DASH-IF IOP v4.3 6.2.5.1.)
+    const scheme = cicpScheme('TransferCharacteristics');
+    const sdrValues = [1, 6, 13, 14, 15];
+    const manifestPromises = [];
+    for (const value of sdrValues) {
+      const manifestText = [
+        '<MPD minBufferTime="PT75S">',
+        '  <Period id="1" duration="PT30S">',
+        '    <AdaptationSet id="2" mimeType="video/mp4">',
+        `      <EssentialProperty schemeIdUri="${scheme}" value="${value}" />`,
+        '      <Representation codecs="avc1.640028">',
+        '        <BaseURL>v-sd.mp4</BaseURL>',
+        '        <SegmentBase indexRange="100-200" />',
+        '      </Representation>',
+        '    </AdaptationSet>',
+        '    <AdaptationSet id="3" mimeType="audio/mp4">',
+        '      <Representation id="audio-en">',
+        '        <BaseURL>a-en.mp4</BaseURL>',
+        '        <SegmentBase indexRange="100-200" />',
+        '      </Representation>',
+        '    </AdaptationSet>',
+        '  </Period>',
+        '</MPD>',
+      ].join('\n');
+
+      fakeNetEngine.setResponseText('dummy://foo', manifestText);
+
+      manifestPromises.push(parser.start('dummy://foo', playerInterface));
+    }
+    const manifests = await Promise.all(manifestPromises);
+    for (const manifest of manifests) {
+      expect(manifest.variants.length).toBe(1);
+      const stream = manifest.variants[0].video;
+      expect(stream.hdr).toBe('SDR');
+    }
+  });
+
   it('Does not error when image adaptation sets are present', async () => {
     const manifestText = [
       '<MPD minBufferTime="PT75S">',
@@ -2108,4 +2221,77 @@ describe('DashParser Manifest', () => {
       expect(uri).not.toContain('/p2/');
     }
   });
+
+  /**
+     * @param {!Array.<number>} periods Start time of multiple periods
+     * @return {string}
+     */
+  function buildManifestWithPeriodStartTime(periods) {
+    const mpdTemplate = [
+      `<MPD type="dynamic"`,
+      'availabilityStartTime="1970-01-01T00:00:00Z"',
+      'timeShiftBufferDepth="PT10H">',
+      '    %(periods)s',
+      '</MPD>',
+    ].join('\n');
+    const periodTemplate = (id, period, duration) => {
+      return [
+        `    <Period id="${id}" start="PT${period}S">`,
+        '        <AdaptationSet mimeType="video/mp4" lang="en" group="1">',
+        '            <SegmentTemplate startNumber="1" media="l-$Number$.mp4">',
+        '                <SegmentTimeline>',
+        `                    <S t="0" d="${duration}" />`,
+        '                </SegmentTimeline>',
+        '            </SegmentTemplate>',
+        '            <Representation id="1"/>',
+        '        </AdaptationSet>',
+        '    </Period>',
+      ].join('\n');
+    };
+    const periodXmls = periods.map((period, i) => {
+      const duration = i+1 === periods.length ? 10 : periods[i+1] - period;
+      // Period start time as ID here. If we use index then there will be
+      // periods with same period ID and different start time which are invalid.
+      return periodTemplate(period, period, duration);
+    });
+    return sprintf(mpdTemplate, {
+      periods: periodXmls.join('\n'),
+    });
+  }
+
+  // Bug description: Inconsistent period start time in the manifests due
+  // to failover triggered in backend servers
+
+  // When one of the servers is down, the manifest will be served by other
+  // redundant servers. The period start time might become out of sync
+  // during the switch-over/recovery.
+
+  it('skip periods that are earlier than max period start time', async () => {
+    const sources = [
+      buildManifestWithPeriodStartTime([5, 15]),
+      buildManifestWithPeriodStartTime([6, 15]), // simulate out-of-sync of +1s
+      buildManifestWithPeriodStartTime([4, 15]), // simulate out-of-sync of -1s
+    ];
+    const segments = [];
+
+    for (const source of sources) {
+      fakeNetEngine.setResponseText('dummy://foo', source);
+      /** @type {shaka.extern.Manifest} */
+      // eslint-disable-next-line no-await-in-loop
+      const manifest = await parser.start('dummy://foo', playerInterface);
+      const video = manifest.variants[0].video;
+      // eslint-disable-next-line no-await-in-loop
+      await video.createSegmentIndex();
+      goog.asserts.assert(video.segmentIndex, 'Null segmentIndex!');
+      segments.push(Array.from(video.segmentIndex));
+    }
+
+    // Expect identical segments
+    expect(segments[0].length).toBe(2);
+    expect(segments[1].length).toBe(2);
+    expect(segments[0][0].startTime).toBe(5);
+    expect(segments[1][0].startTime).toBe(5);
+    expect(segments[0][1].startTime).toBe(15);
+    expect(segments[1][1].startTime).toBe(15);
+  });
 });

package/test/dash/dash_parser_segment_template_unit.js

@@ -127,9 +127,9 @@ describe('DashParser SegmentTemplate', () => {
       // The first segment is number 1 and position 0.
       // Although the segment is 60 seconds long, it is clipped to the period
       // duration of 30 seconds.
-      const references = [
-        ManifestParser.makeReference('s1.mp4', 0, 30, baseUri),
-      ];
+      const ref = ManifestParser.makeReference('s1.mp4', 0, 30, baseUri);
+      ref.trueEndTime = 60;
+      const references = [ref];
       await Dash.testSegmentIndex(source, references);
     });
 

package/test/demo/demo_unit.js

@@ -96,7 +96,6 @@ describe('Demo', () => {
       const configPrimitives = new Set(['number', 'string', 'boolean']);
       const exceptions = new Set()
           .add('preferredVariantRole')
-          .add('preferredTextRole')
           .add('playRangeStart')
           .add('playRangeEnd')
           .add('manifest.dash.keySystemsByURI');

package/test/hls/hls_parser_unit.js

@@ -209,6 +209,46 @@ describe('HlsParser', () => {
     expect(actual).toEqual(manifest);
   });
 
+  it('prioritize AVERAGE-BANDWIDTH to BANDWIDTH', async () => {
+    const master = [
+      '#EXTM3U\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1",',
+      'RESOLUTION=960x540,FRAME-RATE=60,',
+      'AVERAGE-BANDWIDTH=100\n',
+      'video\n',
+    ].join('');
+
+    const media = [
+      '#EXTM3U\n',
+      '#EXT-X-PLAYLIST-TYPE:VOD\n',
+      '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+      '#EXTINF:5,\n',
+      '#EXT-X-BYTERANGE:121090@616\n',
+      'main.mp4',
+    ].join('');
+
+    const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+      manifest.anyTimeline();
+      manifest.addPartialVariant((variant) => {
+        variant.bandwidth = 100;
+        variant.addPartialStream(ContentType.VIDEO, (stream) => {
+          stream.frameRate = 60;
+          stream.mime('video/mp4', 'avc1');
+          stream.size(960, 540);
+        });
+      });
+    });
+
+    fakeNetEngine
+        .setResponseText('test:/master', master)
+        .setResponseText('test:/video', media)
+        .setResponseValue('test:/init.mp4', initSegmentData)
+        .setResponseValue('test:/main.mp4', segmentData);
+
+    const actual = await parser.start('test:/master', playerInterface);
+    expect(actual).toEqual(manifest);
+  });
+
   it('ignores duplicate CODECS', async () => {
     const master = [
       '#EXTM3U\n',
@@ -743,7 +783,7 @@ describe('HlsParser', () => {
       'RESOLUTION=960x540,FRAME-RATE=120,AUDIO="aud2"\n',
       'video2\n',
       '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="eng",',
-      'URI="audio"\n',
+      'DEFAULT=YES,URI="audio"\n',
       '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud2",LANGUAGE="fr",',
       'URI="audio2"\n',
     ].join('');
@@ -761,6 +801,7 @@ describe('HlsParser', () => {
       manifest.anyTimeline();
       manifest.addPartialVariant((variant) => {
         variant.bandwidth = 200;
+        variant.primary = true;
         variant.addPartialStream(ContentType.VIDEO, (stream) => {
           stream.size(960, 540);
         });
@@ -770,6 +811,7 @@ describe('HlsParser', () => {
       });
       manifest.addPartialVariant((variant) => {
         variant.bandwidth = 300;
+        variant.primary = false;
         variant.addPartialStream(ContentType.VIDEO, (stream) => {
           stream.size(960, 540);
         });
@@ -1267,6 +1309,8 @@ describe('HlsParser', () => {
     // stream.
     const timeline = actual.presentationTimeline;
     expect(timeline.getDuration()).toBe(10);
+    expect(timeline.getSeekRangeStart()).toBe(0);
+    expect(timeline.getSeekRangeEnd()).toBe(10);
 
     expect(actual.textStreams.length).toBe(1);
     expect(actual.variants.length).toBe(1);

package/test/media/closed_caption_parser_unit.js

@@ -0,0 +1,20 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.require('shaka.media.ClosedCaptionParser');
+goog.require('shaka.test.Util');
+
+describe('ClosedCaptionParser', () => {
+  it('can handle empty caption packets', async () => {
+    const initSegment = await shaka.test.Util.fetch(
+        'base/test/test/assets/empty_caption_video_init.mp4');
+    const videoSegment = await shaka.test.Util.fetch(
+        'base/test/test/assets/empty_caption_video_segment.mp4');
+    const parser = new shaka.media.ClosedCaptionParser();
+    parser.init(initSegment);
+    parser.parseFrom(videoSegment);
+  });
+});

package/test/media/drm_engine_unit.js

@@ -37,7 +37,7 @@ function testDrmEngine(useMediaCapabilities) {
       navigator.requestMediaKeySystemAccess;
   const originalLogError = shaka.log.error;
   const originalBatchTime = shaka.media.DrmEngine.KEY_STATUS_BATCH_TIME;
-  const originalDecodingInfo = navigator.mediaCapabilities.decodingInfo;
+  const originalDecodingInfo = window.shakaMediaCapabilities.decodingInfo;
 
   /** @type {!jasmine.Spy} */
   let requestMediaKeySystemAccessSpy;
@@ -88,7 +88,7 @@ function testDrmEngine(useMediaCapabilities) {
     navigator.requestMediaKeySystemAccess =
         shaka.test.Util.spyFunc(requestMediaKeySystemAccessSpy);
     decodingInfoSpy = jasmine.createSpy('decodingInfo');
-    navigator.mediaCapabilities.decodingInfo =
+    window.shakaMediaCapabilities.decodingInfo =
         shaka.test.Util.spyFunc(decodingInfoSpy);
 
     logErrorSpy = jasmine.createSpy('shaka.log.error');
@@ -165,7 +165,7 @@ function testDrmEngine(useMediaCapabilities) {
 
     navigator.requestMediaKeySystemAccess =
         originalRequestMediaKeySystemAccess;
-    navigator.mediaCapabilities.decodingInfo = originalDecodingInfo;
+    window.shakaMediaCapabilities.decodingInfo = originalDecodingInfo;
     shaka.log.error = originalLogError;
   });
 
@@ -2278,6 +2278,49 @@ function testDrmEngine(useMediaCapabilities) {
           [drmInfoAudio]);
       expect(returned).toEqual([drmInfoDesired]);
     });
+
+    it('dedupes the merged init data based on keyId matching', () => {
+      const serverCert = new Uint8Array(0);
+      const drmInfoVideo = {
+        keySystem: 'drm.abc',
+        licenseServerUri: 'http://abc.drm/license',
+        distinctiveIdentifierRequired: false,
+        persistentStateRequired: true,
+        videoRobustness: 'really_really_ridiculously_good',
+        serverCertificate: serverCert,
+        serverCertificateUri: '',
+        initData: [{keyId: 'v-init'}],
+        keyIds: new Set(['deadbeefdeadbeefdeadbeefdeadbeef']),
+      };
+      const drmInfoAudio = {
+        keySystem: 'drm.abc',
+        licenseServerUri: undefined,
+        distinctiveIdentifierRequired: true,
+        persistentStateRequired: false,
+        audioRobustness: 'good',
+        serverCertificate: undefined,
+        serverCertificateUri: '',
+        initData: [{keyId: 'v-init'}, {keyId: 'a-init'}],
+        keyIds: new Set(['eadbeefdeadbeefdeadbeefdeadbeefd']),
+      };
+      const drmInfoDesired = {
+        keySystem: 'drm.abc',
+        licenseServerUri: 'http://abc.drm/license',
+        distinctiveIdentifierRequired: true,
+        persistentStateRequired: true,
+        audioRobustness: 'good',
+        videoRobustness: 'really_really_ridiculously_good',
+        serverCertificate: serverCert,
+        initData: [{keyId: 'v-init'}, {keyId: 'a-init'}],
+        keyIds: new Set([
+          'deadbeefdeadbeefdeadbeefdeadbeef',
+          'eadbeefdeadbeefdeadbeefdeadbeefd',
+        ]),
+      };
+      const returned = shaka.media.DrmEngine.getCommonDrmInfos([drmInfoVideo],
+          [drmInfoAudio]);
+      expect(returned).toEqual([drmInfoDesired]);
+    });
   }); // describe('getCommonDrmInfos')
 
   describe('configure', () => {
@@ -2412,6 +2455,19 @@ function testDrmEngine(useMediaCapabilities) {
       await expectAsync(drmEngine.removeSession('abc'))
           .toBeRejectedWith(expected);
     });
+
+    // Regression test for #3534
+    it('does not remove the same session again on destroy', async () => {
+      updatePromise.resolve();
+      expect(session1.remove).not.toHaveBeenCalled();
+      await drmEngine.removeSession('abc');
+      expect(session1.remove).toHaveBeenCalled();
+      session1.remove.calls.reset();
+      await drmEngine.destroy();
+      // The session should only be removed ONCE. If it's double-removed, it
+      // will make a (non-fatal) DOMException.
+      expect(session1.remove).not.toHaveBeenCalled();
+    });
   });
 
   describe('expiration', () => {

package/test/media/playhead_unit.js

@@ -1296,12 +1296,13 @@ describe('Playhead', () => {
     });
 
     // Regression test for https://github.com/google/shaka-player/issues/2987
-    it('does gap jump if paused at 0', () => {
+    it('does gap jump if paused at 0 and has autoplay', () => {
       const buffered = [{start: 10, end: 20}];
       video.buffered = createFakeBuffered(buffered);
       video.currentTime = 0;
       video.readyState = HTMLMediaElement.HAVE_ENOUGH_DATA;
       video.paused = true;
+      video.autoplay = true;
 
       config.jumpLargeGaps = true;
       playhead = new shaka.media.MediaSourcePlayhead(
@@ -1319,6 +1320,31 @@ describe('Playhead', () => {
       expect(video.currentTime).toBe(10);
     });
 
+    // Regression test for https://github.com/google/shaka-player/issues/3451
+    it('doesn\'t gap jump if paused at 0 and hasn\'t autoplay', () => {
+      const buffered = [{start: 10, end: 20}];
+      video.buffered = createFakeBuffered(buffered);
+      video.currentTime = 0;
+      video.readyState = HTMLMediaElement.HAVE_ENOUGH_DATA;
+      video.paused = true;
+      video.autoplay = false;
+
+      config.jumpLargeGaps = true;
+      playhead = new shaka.media.MediaSourcePlayhead(
+          video,
+          manifest,
+          config,
+          /* startTime= */ 0,
+          Util.spyFunc(onSeek),
+          Util.spyFunc(onEvent));
+
+      playhead.notifyOfBufferingChange();
+      jasmine.clock().tick(500);
+
+      // There should NOT have been a gap jump.
+      expect(video.currentTime).toBe(0);
+    });
+
     /**
      * @param {string} name
      * @param {SeekTestInfo} data

package/test/media/presentation_timeline_unit.js

@@ -290,6 +290,25 @@ describe('PresentationTimeline', () => {
       // last segment time (50)
       expect(timeline.getSegmentAvailabilityEnd()).toBe(50);
     });
+
+    it('calculates time when there a transition of live to static', () => {
+      const timeline = makeLiveTimeline(/* availability= */ 20);
+
+      const ref1 = makeSegmentReference(0, 10);
+      const ref2 = makeSegmentReference(10, 20);
+      const ref3 = makeSegmentReference(20, 30);
+      const ref4 = makeSegmentReference(30, 40);
+      const ref5 = makeSegmentReference(40, 50);
+
+      setElapsed(50);
+      timeline.notifySegments([ref1, ref2, ref3, ref4, ref5]);
+
+      expect(timeline.getSegmentAvailabilityEnd()).toBe(50);
+
+      timeline.setStatic(true);
+
+      expect(timeline.getSegmentAvailabilityEnd()).toBe(50);
+    });
   });
 
   describe('getDuration', () => {

package/test/media/segment_index_unit.js

@@ -484,12 +484,40 @@ describe('SegmentIndex', /** @suppress {accessControls} */ () => {
         makeReference(uri(20), 20, 30),
       ];
 
-      // The first reference ends before the availabilityWindowStart, so it
-      // should be discarded.
-      index1.mergeAndEvict(references2, 19);
+      // The first two references end before the availabilityWindowStart, so
+      // they should be discarded.
+      index1.mergeAndEvict(references2, 21);
+      expect(index1.references.length).toBe(1);
+      expect(index1.references[0]).toEqual(references2[2]);
+    });
+
+    it('discards segments that end before the first old segment', () => {
+      /** @type {!Array.<!shaka.media.SegmentReference>} */
+      const references1 = [
+        // Assuming ref(0, 10) has been already evicted
+        makeReference(uri(10), 10, 20),
+      ];
+      const index1 = new shaka.media.SegmentIndex(references1);
+      const position1 = index1.find(10);
+
+      /** @type {!Array.<!shaka.media.SegmentReference>} */
+      const references2 = [
+        makeReference(uri(0), 0, 10),
+        makeReference(uri(10), 10, 20),
+        makeReference(uri(20), 20, 30),
+      ];
+
+      // The new first reference ends before the first old reference starts, so
+      // it should be discarded.  We will never grow the list at the beginning.
+      index1.mergeAndEvict(references2, 0);
       expect(index1.references.length).toBe(2);
       expect(index1.references[0]).toEqual(references2[1]);
       expect(index1.references[1]).toEqual(references2[2]);
+
+      // The positions should be the same, as well.
+      expect(index1.find(10)).toBe(position1);
+      goog.asserts.assert(position1 != null, 'Position should not be null!');
+      expect(index1.get(position1)).toBe(references2[1]);
     });
   });
 
@@ -567,6 +595,12 @@ describe('SegmentIndex', /** @suppress {accessControls} */ () => {
       makeReference(uri(20.30), 20, 30),
     ];
 
+    const additionalRefs = [
+      makeReference(uri(30.40), 30, 40),
+      makeReference(uri(40.50), 40, 50),
+      makeReference(uri(50.60), 50, 60),
+    ];
+
     const partialRefs1 = [
       makeReference(uri(10.15), 10, 15),
       makeReference(uri(15.20), 15, 20),
@@ -626,6 +660,45 @@ describe('SegmentIndex', /** @suppress {accessControls} */ () => {
       expect(Array.from(index)).toEqual(inputRefs.slice(1));
     });
 
+    it('resumes iteration after new references are added', () => {
+      const refs = inputRefs.slice();
+      const index = new shaka.media.SegmentIndex(refs);
+
+      // This simulates the pattern of calls in StreamingEngine when we buffer
+      // to the edge of a live stream.
+      const iterator = index[Symbol.iterator]();
+      iterator.next();
+      expect(iterator.current()).toBe(inputRefs[0]);
+
+      iterator.next();
+      expect(iterator.current()).toBe(inputRefs[1]);
+
+      iterator.next();
+      expect(iterator.current()).toBe(inputRefs[2]);
+
+      iterator.next();
+      expect(iterator.current()).toBe(null);
+      // After we reach the end of the iteration, we should still get null back
+      // on subsequent requests.
+      expect(iterator.current()).toBe(null);
+      expect(iterator.current()).toBe(null);
+
+      // Although we have reached the end, we should still be able to add new
+      // references and iterate to them without starting over the iteration.
+      refs.push(...additionalRefs);
+
+      expect(iterator.current()).toBe(additionalRefs[0]);
+
+      iterator.next();
+      expect(iterator.current()).toBe(additionalRefs[1]);
+
+      iterator.next();
+      expect(iterator.current()).toBe(additionalRefs[2]);
+
+      iterator.next();
+      expect(iterator.current()).toBe(null);
+    });
+
     describe('seek', () => {
       it('returns the matching segment', () => {
         const index = new shaka.media.SegmentIndex(inputRefs);

package/test/media/streaming_engine_unit.js

@@ -835,7 +835,7 @@ describe('StreamingEngine', () => {
     // This would let some media types buffer faster than others if unchecked.
     netEngineDelays.text = 0.1;
     netEngineDelays.audio = 1.0;
-    netEngineDelays.video = 10.0;
+    netEngineDelays.video = 5.0; // Need init segment and media segment
 
     mediaSourceEngine.appendBuffer.and.callFake((type, data, start, end) => {
       // Call to the underlying implementation.
@@ -2170,13 +2170,13 @@ describe('StreamingEngine', () => {
               .bind(mediaSourceEngine);
 
       mediaSourceEngine.remove.and.callFake((type, start, end) => {
-        expect(presentationTimeInSeconds).toBe(20);
+        expect(presentationTimeInSeconds).toBeGreaterThanOrEqual(20);
         expect(start).toBe(0);
         expect(end).toBe(10);
 
         if (mediaSourceEngine.remove.calls.count() == 3) {
           mediaSourceEngine.remove.and.callFake((type, start, end) => {
-            expect(presentationTimeInSeconds).toBe(30);
+            expect(presentationTimeInSeconds).toBeGreaterThanOrEqual(30);
             expect(start).toBe(10);
             expect(end).toBe(20);
             return originalRemove(type, start, end);

package/test/player_integration.js

@@ -652,6 +652,44 @@ describe('Player', () => {
     });
   });
 
+  describe('seek range', () => {
+    // Regression test for Issue #3675.
+    it('has a reasonable seek range after going from live to VOD', async () => {
+      const netEngine = player.getNetworkingEngine();
+      const startTime = Date.now();
+      netEngine.registerRequestFilter((type, request) => {
+        if (type != shaka.net.NetworkingEngine.RequestType.MANIFEST) {
+          return;
+        }
+        // Simulate a live stream by providing different manifests over time.
+        const time = (Date.now() - startTime) / 1000;
+        const manifestNumber = Math.min(5, Math.floor(0.5 + time / 2));
+        request.uris = [
+          '/base/test/test/assets/3675/dash_' + manifestNumber + '.mpd',
+        ];
+        console.log('getting manifest', request.uris);
+      });
+
+      // Play the stream.
+      await player.load('/base/test/test/assets/3675/dash_0.mpd');
+      video.play();
+
+      // Wait for the stream to be over.
+      eventManager.listen(player, 'error', Util.spyFunc(onErrorSpy));
+      /** @type {shaka.test.Waiter} */
+      const waiter = new shaka.test.Waiter(eventManager)
+          .timeoutAfter(20).failOnTimeout(true);
+      await waiter.waitForEnd(video);
+
+      // The stream should have transitioned to VOD by now.
+      expect(player.isLive()).toBe(false);
+
+      // Check that the final seek range is as expected.
+      const seekRange = player.seekRange();
+      expect(seekRange.end).toBe(14);
+    });
+  });
+
   describe('buffering', () => {
     const startBuffering = jasmine.objectContaining({buffering: true});
     const endBuffering = jasmine.objectContaining({buffering: false});