shaka-player 3.2.0 → 3.2.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);
@@ -975,7 +983,8 @@ describe('DashParser Manifest', () => {
 
     it('duplicate Representation ids with live', async () => {
       const source = [
-        '<MPD minBufferTime="PT75S" type="dynamic">',
+        '<MPD minBufferTime="PT75S" type="dynamic"',
+        '     availabilityStartTime="1970-01-01T00:00:00Z">',
         '  <Period id="1" duration="PT30S">',
         '    <AdaptationSet mimeType="video/mp4">',
         '      <Representation id="1" bandwidth="1">',
@@ -1864,7 +1873,7 @@ describe('DashParser Manifest', () => {
     expect(textStream.kind).toBe('caption');
   });
 
-  it('converts Roles element to "forced"', async () => {
+  it('converts Roles element to "forced" (old role)', async () => {
     const manifestText = [
       '<MPD minBufferTime="PT75S">',
       '  <Period id="1" duration="PT30S">',
@@ -1896,7 +1905,40 @@ describe('DashParser Manifest', () => {
     expect(textStream.forced).toBe(true);
   });
 
-  it('supports HDR signaling', async () => {
+  it('converts Roles element to "forced"', async () => {
+    const manifestText = [
+      '<MPD minBufferTime="PT75S">',
+      '  <Period id="1" duration="PT30S">',
+      '    <AdaptationSet id="1" contentType="text">',
+      '      <Accessibility schemeIdUri="urn:mpeg:dash:role:2011" ',
+      '          value="captions" />',
+      '      <Accessibility schemeIdUri="urn:mpeg:dash:role:2011" ',
+      '          value="forced-subtitle" />',
+      '      <Accessibility schemeIdUri="foobar" value="bar" />',
+      '      <Representation id="text-en" mimeType="text/webvtt">',
+      '        <BaseURL>t-en.vtt</BaseURL>',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '    <AdaptationSet id="1" mimeType="video/mp4">',
+      '      <Representation id="video-sd" width="640" height="480">',
+      '        <BaseURL>v-sd.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);
+    const textStream = manifest.textStreams[0];
+    expect(textStream.roles).toEqual(['captions', 'forced-subtitle']);
+    expect(textStream.forced).toBe(true);
+  });
+
+  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 = [
@@ -1927,6 +1969,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">',
@@ -2150,4 +2296,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/hls/hls_parser_unit.js

@@ -209,6 +209,80 @@ describe('HlsParser', () => {
     expect(actual).toEqual(manifest);
   });
 
+  it('parses manifest attributes with space', async () => {
+    const master = [
+      '#EXTM3U\n',
+      '#EXT-X-MEDIA:TYPE=AUDIO, GROUP-ID="aud1", LANGUAGE="eng", ',
+      'CHANNELS="16/JOC", URI="audio"\n',
+      '#EXT-X-MEDIA:TYPE=SUBTITLES, GROUP-ID="sub1", LANGUAGE="eng", ',
+      'URI="text"\n',
+      '#EXT-X-MEDIA:TYPE=SUBTITLES, GROUP-ID="sub2", LANGUAGE="es", ',
+      'URI="text2"\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=200, CODECS="avc1,mp4a", ',
+      'RESOLUTION=960x540, FRAME-RATE=60, AUDIO="aud1"\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 textMedia = [
+      '#EXTM3U\n',
+      '#EXT-X-PLAYLIST-TYPE:VOD\n',
+      '#EXTINF:5,\n',
+      '#EXT-X-BYTERANGE:121090@616\n',
+      'main.vtt',
+    ].join('');
+
+    const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+      manifest.anyTimeline();
+      manifest.addPartialVariant((variant) => {
+        variant.language = 'en';
+        variant.bandwidth = 200;
+        variant.addPartialStream(ContentType.VIDEO, (stream) => {
+          stream.frameRate = 60;
+          stream.mime('video/mp4', 'avc1');
+          stream.size(960, 540);
+        });
+        variant.addPartialStream(ContentType.AUDIO, (stream) => {
+          stream.language = 'en';
+          stream.channelsCount = 16;
+          stream.spatialAudio = true;
+          stream.mime('audio/mp4', 'mp4a');
+        });
+      });
+      manifest.addPartialTextStream((stream) => {
+        stream.language = 'en';
+        stream.kind = TextStreamKind.SUBTITLE;
+        stream.mime('text/vtt', '');
+      });
+      manifest.addPartialTextStream((stream) => {
+        stream.language = 'es';
+        stream.kind = TextStreamKind.SUBTITLE;
+        stream.mime('text/vtt', '');
+      });
+    });
+
+    fakeNetEngine
+        .setResponseText('test:/master', master)
+        .setResponseText('test:/audio', media)
+        .setResponseText('test:/video', media)
+        .setResponseText('test:/text', textMedia)
+        .setResponseText('test:/text2', textMedia)
+        .setResponseText('test:/main.vtt', vttText)
+        .setResponseValue('test:/init.mp4', initSegmentData)
+        .setResponseValue('test:/main.mp4', segmentData);
+
+    const actual = await parser.start('test:/master', playerInterface);
+    expect(actual).toEqual(manifest);
+  });
+
   it('prioritize AVERAGE-BANDWIDTH to BANDWIDTH', async () => {
     const master = [
       '#EXTM3U\n',
@@ -783,7 +857,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('');
@@ -801,6 +875,7 @@ describe('HlsParser', () => {
       manifest.anyTimeline();
       manifest.addPartialVariant((variant) => {
         variant.bandwidth = 200;
+        variant.primary = true;
         variant.addPartialStream(ContentType.VIDEO, (stream) => {
           stream.size(960, 540);
         });
@@ -810,6 +885,7 @@ describe('HlsParser', () => {
       });
       manifest.addPartialVariant((variant) => {
         variant.bandwidth = 300;
+        variant.primary = false;
         variant.addPartialStream(ContentType.VIDEO, (stream) => {
           stream.size(960, 540);
         });
@@ -1307,6 +1383,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_integration.js

@@ -162,7 +162,7 @@ describe('DrmEngine', () => {
     document.body.removeChild(video);
   });
 
-  function checkSupport() {
+  function checkTrueDrmSupport() {
     if (shaka.util.Platform.isXboxOne()) {
       // Axinom won't issue a license for an Xbox One.  The error message from
       // the license server says "Your DRM client's security level is 150, but
@@ -174,7 +174,11 @@ describe('DrmEngine', () => {
     return support['com.widevine.alpha'] || support['com.microsoft.playready'];
   }
 
-  filterDescribe('basic flow', checkSupport, () => {
+  function checkClearKeySupport() {
+    return support['org.w3.clearkey'];
+  }
+
+  filterDescribe('basic flow', checkTrueDrmSupport, () => {
     drmIt('gets a license and can play encrypted segments', async () => {
       // The error callback should not be invoked.
       onErrorSpy.and.callFake(fail);
@@ -274,4 +278,84 @@ describe('DrmEngine', () => {
       expect(video.currentTime).toBeGreaterThan(0);
     });
   });  // describe('basic flow')
+
+  filterDescribe('ClearKey', checkClearKeySupport, () => {
+    drmIt('plays encrypted content with the ClearKey CDM', async () => {
+      // Configure DrmEngine for ClearKey playback.
+      const config = shaka.util.PlayerConfiguration.createDefault().drm;
+      config.clearKeys = {
+        // From https://github.com/Axinom/public-test-vectors/tree/conservative#v61-multidrm
+        '6e5a1d26275747d78046eaa5d1d34b5a': '197f26f572c864d2338b3ae5d114ea9c',
+      };
+      drmEngine.configure(config);
+
+      // The error callback should not be invoked.
+      onErrorSpy.and.callFake(fail);
+
+      /** @type {!shaka.util.PublicPromise} */
+      const encryptedEventSeen = new shaka.util.PublicPromise();
+      eventManager.listen(video, 'encrypted', () => {
+        encryptedEventSeen.resolve();
+      });
+      eventManager.listen(video, 'error', () => {
+        fail('MediaError code ' + video.error.code);
+        let extended = video.error.msExtendedCode;
+        if (extended) {
+          if (extended < 0) {
+            extended += Math.pow(2, 32);
+          }
+          fail('MediaError msExtendedCode ' + extended.toString(16));
+        }
+      });
+
+      /** @type {!shaka.util.PublicPromise} */
+      const keyStatusEventSeen = new shaka.util.PublicPromise();
+      onKeyStatusSpy.and.callFake(() => {
+        keyStatusEventSeen.resolve();
+      });
+
+      const variants = manifest.variants;
+
+      await drmEngine.initForPlayback(variants, manifest.offlineSessionIds);
+      await drmEngine.attach(video);
+      await mediaSourceEngine.appendBuffer(
+          ContentType.VIDEO, videoInitSegment, null, null,
+          /* hasClosedCaptions= */ false);
+      await mediaSourceEngine.appendBuffer(
+          ContentType.AUDIO, audioInitSegment, null, null,
+          /* hasClosedCaptions= */ false);
+      await encryptedEventSeen;
+
+      // Some platforms (notably 2017 Tizen TVs) do not fire key status
+      // events.
+      const keyStatusTimeout = shaka.test.Util.delay(5);
+      await Promise.race([keyStatusTimeout, keyStatusEventSeen]);
+
+      const call = onKeyStatusSpy.calls.mostRecent();
+      if (call) {
+        const map = /** @type {!Object} */ (call.args[0]);
+        expect(Object.keys(map).length).not.toBe(0);
+        for (const k in map) {
+          expect(map[k]).toBe('usable');
+        }
+      }
+
+      await mediaSourceEngine.appendBuffer(
+          ContentType.VIDEO, videoSegment, 0, 10,
+          /* hasClosedCaptions= */ false);
+      await mediaSourceEngine.appendBuffer(
+          ContentType.AUDIO, audioSegment, 0, 10,
+          /* hasClosedCaptions= */ false);
+
+      expect(video.buffered.end(0)).toBeGreaterThan(0);
+      video.play();
+
+      const waiter = new shaka.test.Waiter(eventManager).timeoutAfter(15);
+      await waiter.waitForMovement(video);
+
+      // Something should have played by now.
+      expect(video.readyState).toBeGreaterThan(1);
+      expect(video.currentTime).toBeGreaterThan(0);
+    });
+  });  // describe('ClearKey')
 });

package/test/media/drm_engine_unit.js

@@ -2152,6 +2152,50 @@ describe('DrmEngine', () => {
           [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,
+        serverCertificateUri: '',
+        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', () => {
@@ -2285,6 +2329,19 @@ describe('DrmEngine', () => {
       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