shaka-player 3.3.4 → 4.0.1

package/shaka-player.uncompiled.js

@@ -35,12 +35,9 @@ goog.require('shaka.offline.indexeddb.StorageMechanism');
 goog.require('shaka.polyfill.Aria');
 goog.require('shaka.polyfill.EncryptionScheme');
 goog.require('shaka.polyfill.Fullscreen');
-goog.require('shaka.polyfill.MathRound');
 goog.require('shaka.polyfill.MediaSource');
 goog.require('shaka.polyfill.MediaCapabilities');
 goog.require('shaka.polyfill.Orientation');
-goog.require('shaka.polyfill.PatchedMediaKeysApple');
-goog.require('shaka.polyfill.PatchedMediaKeysMs');
 goog.require('shaka.polyfill.PatchedMediaKeysNop');
 goog.require('shaka.polyfill.PatchedMediaKeysWebkit');
 goog.require('shaka.polyfill.PiPWebkit');

package/test/cast/cast_utils_unit.js

@@ -189,6 +189,7 @@ describe('CastUtils', () => {
         const fakeVideoStream = {
           mimeType: 'video/mp4',
           codecs: 'avc1.42c01e',
+          drmInfos: [],
         };
         const initSegmentUrl = '/base/test/test/assets/sintel-video-init.mp4';
         const videoSegmentUrl =

package/test/dash/dash_parser_content_protection_unit.js

@@ -805,6 +805,50 @@ describe('DashParser ContentProtection', () => {
     });
   });
 
+  describe('getClearKeyLicenseUrl', () => {
+    it('valid clearkey:Laurl node', () => {
+      const input = {
+        init: null,
+        keyId: null,
+        schemeUri: '',
+        node: strToXml([
+          '<test xmlns:clearkey="http://dashif.org/guidelines/clearKey">',
+          '  <clearkey:Laurl ',
+          '     Lic_type="EME-1.0">www.example.com</clearkey:Laurl>',
+          '</test>',
+        ].join('\n')),
+      };
+      const actual = ContentProtection.getClearKeyLicenseUrl(input);
+      expect(actual).toBe('www.example.com');
+    });
+
+    it('clearkey:Laurl without license url', () => {
+      const input = {
+        init: null,
+        keyId: null,
+        schemeUri: '',
+        node: strToXml([
+          '<test xmlns:clearkey="http://dashif.org/guidelines/clearKey">',
+          '  <clearkey:Laurl Lic_type="EME-1.0"></clearkey:Laurl>',
+          '</test>',
+        ].join('\n')),
+      };
+      const actual = ContentProtection.getClearKeyLicenseUrl(input);
+      expect(actual).toBe('');
+    });
+
+    it('no clearkey:Laurl node', () => {
+      const input = {
+        init: null,
+        keyId: null,
+        schemeUri: '',
+        node: strToXml('<test></test>'),
+      };
+      const actual = ContentProtection.getClearKeyLicenseUrl(input);
+      expect(actual).toBe('');
+    });
+  });
+
   describe('getPlayReadyLicenseURL', () => {
     it('mspro', () => {
       const laurl = [

package/test/dash/dash_parser_manifest_unit.js

@@ -447,30 +447,6 @@ describe('DashParser Manifest', () => {
         expect(stream.closedCaptions).toEqual(expectedClosedCaptions);
       });
 
-  it('Detects E-AC3 JOC content by SupplementalProperty', async () => {
-    const idUri = 'tag:dolby.com,2018:dash:EC3_ExtensionType:2018';
-    const source = [
-      '<MPD>',
-      '  <Period duration="PT30M">',
-      '    <AdaptationSet mimeType="audio/mp4" lang="\u2603">',
-      '      <Representation bandwidth="500">',
-      '        <SupplementalProperty schemeIdUri="' + idUri + '" value="JOC"/>',
-      '        <BaseURL>http://example.com</BaseURL>',
-      '        <SegmentTemplate media="2.mp4" duration="1" />',
-      '      </Representation>',
-      '    </AdaptationSet>',
-      '  </Period>',
-      '</MPD>',
-    ].join('\n');
-
-    fakeNetEngine.setResponseText('dummy://foo', source);
-
-    /** @type {shaka.extern.Manifest} */
-    const manifest = await parser.start('dummy://foo', playerInterface);
-    const stream = manifest.variants[0].audio;
-    expect(stream.mimeType).toBe('audio/eac3-joc');
-  });
-
   it('Detects spatial audio', async () => {
     const idUri = 'tag:dolby.com,2018:dash:EC3_ExtensionType:2018';
     const source = [

package/test/dash/dash_parser_segment_template_unit.js

@@ -106,9 +106,8 @@ describe('DashParser SegmentTemplate', () => {
           's2.mp4', 50, 60, baseUri);
       expectedRef2.timestampOffset = -10;
 
-      const iterator = stream.segmentIndex[Symbol.iterator]();
-      const ref1 = iterator.seek(45);
-      const ref2 = iterator.seek(55);
+      const ref1 = stream.segmentIndex.getIteratorForTime(45).next().value;
+      const ref2 = stream.segmentIndex.getIteratorForTime(55).next().value;
       expect(ref1).toEqual(expectedRef1);
       expect(ref2).toEqual(expectedRef2);
     });
@@ -445,7 +444,7 @@ describe('DashParser SegmentTemplate', () => {
       await variants[2].video.createSegmentIndex();
 
       const getRefAt = (stream, time) => {
-        return stream.segmentIndex[Symbol.iterator]().seek(time);
+        return stream.segmentIndex.getIteratorForTime(time).next().value;
       };
 
       expect(getRefAt(variants[0].video, 0)).toEqual(

package/test/demo/demo_unit.js

@@ -93,7 +93,8 @@ describe('Demo', () => {
           .add('preferredVariantRole')
           .add('playRangeStart')
           .add('playRangeEnd')
-          .add('manifest.dash.keySystemsByURI');
+          .add('manifest.dash.keySystemsByURI')
+          .add('manifest.hls.mediaPlaylistFullMimeType');
 
       /**
        * @param {!Object} section

package/test/hls/hls_live_unit.js

@@ -28,14 +28,6 @@ describe('HlsParser live', () => {
   let segmentData;
   /** @type {!Uint8Array} */
   let selfInitializingSegmentData;
-  /** @type {!Uint8Array} */
-  let tsSegmentData;
-  /** @type {!Uint8Array} */
-  let pastRolloverSegmentData;
-  /** @type {number} */
-  let rolloverOffset;
-  /** @type {number} */
-  let segmentDataStartTime;
 
   beforeEach(() => {
     // TODO: use StreamGenerator?
@@ -66,36 +58,6 @@ describe('HlsParser live', () => {
       0x00, 0x00, 0x00, 0x00, // baseMediaDecodeTime first 4 bytes
       0x00, 0x00, 0x07, 0xd0,  // baseMediaDecodeTime last 4 bytes (2000)
     ]);
-    tsSegmentData = new Uint8Array([
-      0x47, // TS sync byte (fixed value)
-      0x41, 0x01, // not corrupt, payload follows, packet ID 257
-      0x10, // not scrambled, no adaptation field, payload only, seq #0
-      0x00, 0x00, 0x01, // PES start code (fixed value)
-      0xe0, // stream ID (video stream 0)
-      0x00, 0x00, // PES packet length (doesn't matter)
-      0x80, // marker bits (fixed value), not scrambled, not priority
-      0x80, // PTS only, no DTS, other flags 0 (don't matter)
-      0x05, // remaining PES header length == 5 (one timestamp)
-      0x21, 0x00, 0x0b, 0x7e, 0x41, // PTS = 180000, encoded into 5 bytes
-    ]);
-    // 180000 divided by TS timescale (90000) = segment starts at 2s.
-    segmentDataStartTime = 2;
-
-    pastRolloverSegmentData = new Uint8Array([
-      0x00, 0x00, 0x00, 0x24, // size (36)
-      0x6D, 0x6F, 0x6F, 0x66, // type (moof)
-      0x00, 0x00, 0x00, 0x1C, // traf size (28)
-      0x74, 0x72, 0x61, 0x66, // type (traf)
-      0x00, 0x00, 0x00, 0x14, // tfdt size (20)
-      0x74, 0x66, 0x64, 0x74, // type (tfdt)
-      0x01, 0x00, 0x00, 0x00, // version and flags
-      0x00, 0x00, 0x00, 0x00, // baseMediaDecodeTime first 4 bytes
-      0x0b, 0x60, 0xbc, 0x28,  // baseMediaDecodeTime last 4 bytes (190889000)
-    ]);
-
-    // The timestamp above would roll over twice, so this rollover offset should
-    // be applied.
-    rolloverOffset = (0x200000000 * 2) / 90000;
 
     selfInitializingSegmentData =
         shaka.util.Uint8ArrayUtils.concat(initSegmentData, segmentData);
@@ -221,8 +183,10 @@ describe('HlsParser live', () => {
 
     describe('update', () => {
       it('adds new segments when they appear', async () => {
-        const ref1 = ManifestParser.makeReference('test:/main.mp4', 2, 4);
-        const ref2 = ManifestParser.makeReference('test:/main2.mp4', 4, 6);
+        const ref1 = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null);
+        const ref2 = makeReference(
+            'test:/main2.mp4', 2, 4, /* syncTime= */ null);
 
         await testUpdate(
             master, media, [ref1], mediaWithAdditionalSegment, [ref1, ref2]);
@@ -236,8 +200,10 @@ describe('HlsParser live', () => {
         ].join('');
 
         const masterWithTwoVariants = master + secondVariant;
-        const ref1 = ManifestParser.makeReference('test:/main.mp4', 2, 4);
-        const ref2 = ManifestParser.makeReference('test:/main2.mp4', 4, 6);
+        const ref1 = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null);
+        const ref2 = makeReference(
+            'test:/main2.mp4', 2, 4, /* syncTime= */ null);
 
         await testUpdate(
             masterWithTwoVariants, media, [ref1], mediaWithAdditionalSegment,
@@ -257,8 +223,10 @@ describe('HlsParser live', () => {
         ].join('');
 
         const masterWithAudio = masterlist + audio;
-        const ref1 = ManifestParser.makeReference('test:/main.mp4', 2, 4);
-        const ref2 = ManifestParser.makeReference('test:/main2.mp4', 4, 6);
+        const ref1 = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null);
+        const ref2 = makeReference(
+            'test:/main2.mp4', 2, 4, /* syncTime= */ null);
 
         await testUpdate(
             masterWithAudio, media, [ref1], mediaWithAdditionalSegment,
@@ -278,9 +246,12 @@ describe('HlsParser live', () => {
 
         const updatedMedia1 = media + newSegment1;
         const updatedMedia2 = updatedMedia1 + newSegment2;
-        const ref1 = ManifestParser.makeReference('test:/main.mp4', 2, 4);
-        const ref2 = ManifestParser.makeReference('test:/main2.mp4', 4, 6);
-        const ref3 = ManifestParser.makeReference('test:/main3.mp4', 6, 8);
+        const ref1 = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null);
+        const ref2 = makeReference(
+            'test:/main2.mp4', 2, 4, /* syncTime= */ null);
+        const ref3 = makeReference(
+            'test:/main3.mp4', 4, 6, /* syncTime= */ null);
 
         fakeNetEngine
             .setResponseText('test:/master', master)
@@ -386,19 +357,6 @@ describe('HlsParser live', () => {
       'main.mp4\n',
     ].join('');
 
-    const mediaWithByteRange = [
-      '#EXTM3U\n',
-      '#EXT-X-TARGETDURATION:5\n',
-      '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
-      '#EXT-X-MEDIA-SEQUENCE:0\n',
-      '#EXT-X-BYTERANGE:121090@616\n',
-      '#EXTINF:2,\n',
-      'main.mp4\n',
-    ].join('');
-
-    const expectedStartByte = 616;
-    const expectedEndByte = 121705;
-
     const mediaWithAdditionalSegment = [
       '#EXTM3U\n',
       '#EXT-X-TARGETDURATION:5\n',
@@ -563,17 +521,17 @@ describe('HlsParser live', () => {
           .setResponseValue('test:/main.mp4', segmentData)
           .setResponseValue('test:/main2.mp4', segmentData);
 
-      const ref1 = ManifestParser.makeReference(
-          'test:/main.mp4', segmentDataStartTime, segmentDataStartTime + 2,
+      const ref1 = makeReference(
+          'test:/main.mp4', 0, 2, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
           /* timestampOffset= */ 0);
 
       // Expect the timestamp offset to be set for the segment after the
       // EXT-X-DISCONTINUITY tag.
-      const ref2 = ManifestParser.makeReference(
-          'test:/main2.mp4', segmentDataStartTime + 2, segmentDataStartTime + 4,
+      const ref2 = makeReference(
+          'test:/main2.mp4', 2, 4, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
-          /* timestampOffset= */ 2);
+          /* timestampOffset= */ 0);
 
       const manifest = await parser.start('test:/master', playerInterface);
       const video = manifest.variants[0].video;
@@ -581,57 +539,6 @@ describe('HlsParser live', () => {
       ManifestParser.verifySegmentIndex(video, [ref1, ref2]);
     });
 
-    it('offsets VTT text with rolled over TS timestamps', async () => {
-      const masterWithVtt = [
-        '#EXTM3U\n',
-        '#EXT-X-MEDIA:TYPE=SUBTITLES,LANGUAGE="fra",URI="text",',
-        'GROUP-ID="sub1"\n',
-        '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1",',
-        'RESOLUTION=960x540,FRAME-RATE=60,SUBTITLES="sub1"\n',
-        'video\n',
-      ].join('');
-
-      const textPlaylist = [
-        '#EXTM3U\n',
-        '#EXT-X-TARGETDURATION:5\n',
-        '#EXT-X-MEDIA-SEQUENCE:0\n',
-        '#EXTINF:2,\n',
-        'main.vtt\n',
-      ].join('');
-
-      const vtt = [
-        'WEBVTT\n',
-        '\n',
-        '00:00.000 --> 00:01.000\n',
-        'Hello, world!\n',
-      ].join('');
-
-      fakeNetEngine
-          .setResponseText('test:/master', masterWithVtt)
-          .setResponseText('test:/video', media)
-          .setResponseText('test:/text', textPlaylist)
-          .setResponseValue('test:/init.mp4', initSegmentData)
-          .setResponseValue('test:/main.mp4', pastRolloverSegmentData)
-          .setResponseText('test:/main.vtt', vtt);
-
-      const manifest = await parser.start('test:/master', playerInterface);
-      const textStream = manifest.textStreams[0];
-      await textStream.createSegmentIndex();
-      goog.asserts.assert(textStream.segmentIndex, 'Null segmentIndex!');
-
-      let ref = Array.from(textStream.segmentIndex)[0];
-      expect(ref).not.toBe(null);
-      expect(ref.startTime).not.toBeLessThan(rolloverOffset);
-
-      const videoStream = manifest.variants[0].video;
-      await videoStream.createSegmentIndex();
-      goog.asserts.assert(videoStream.segmentIndex, 'Null segmentIndex!');
-
-      ref = Array.from(videoStream.segmentIndex)[0];
-      expect(ref).not.toBe(null);
-      expect(ref.startTime).not.toBeLessThan(rolloverOffset);
-    });
-
     it('parses streams with partial and preload hinted segments', async () => {
       playerInterface.isLowLatencyMode = () => true;
       const mediaWithPartialSegments = [
@@ -661,35 +568,32 @@ describe('HlsParser live', () => {
           .setResponseValue('test:/partial.mp4', segmentData)
           .setResponseValue('test:/partial2.mp4', segmentData);
 
-      const partialRef = ManifestParser.makeReference(
-          'test:/partial.mp4', segmentDataStartTime, segmentDataStartTime + 2,
+      const partialRef = makeReference(
+          'test:/partial.mp4', 0, 2, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 199);
 
-      const partialRef2 = ManifestParser.makeReference(
-          'test:/partial2.mp4', segmentDataStartTime + 2,
-          segmentDataStartTime + 4, /* baseUri= */ '', /* startByte= */ 200,
-          /* endByte= */ 429);
+      const partialRef2 = makeReference(
+          'test:/partial2.mp4', 2, 4, /* syncTime= */ null,
+          /* baseUri= */ '', /* startByte= */ 200, /* endByte= */ 429);
 
-      const partialRef3 = ManifestParser.makeReference(
-          'test:/partial.mp4', segmentDataStartTime + 4,
-          segmentDataStartTime + 6,
+      const partialRef3 = makeReference(
+          'test:/partial.mp4', 4, 6, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 209);
 
       // A preload hinted partial segment doesn't have duration information,
       // so its startTime and endTime are the same.
-      const preloadRef = ManifestParser.makeReference(
-          'test:/partial.mp4', segmentDataStartTime + 6,
-          segmentDataStartTime + 6,
+      const preloadRef = makeReference(
+          'test:/partial.mp4', 6, 6, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 210, /* endByte= */ null);
 
-      const ref = ManifestParser.makeReference(
-          'test:/main.mp4', segmentDataStartTime, segmentDataStartTime + 4,
+      const ref = makeReference(
+          'test:/main.mp4', 0, 4, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 429,
           /* timestampOffset= */ 0, [partialRef, partialRef2]);
 
       // ref2 is not fully published yet, so it doesn't have a segment uri.
-      const ref2 = ManifestParser.makeReference(
-          '', segmentDataStartTime + 4, segmentDataStartTime + 6,
+      const ref2 = makeReference(
+          '', 4, 6, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
           /* timestampOffset= */ 0, [partialRef3, preloadRef]);
 
@@ -699,18 +603,44 @@ describe('HlsParser live', () => {
       ManifestParser.verifySegmentIndex(video, [ref, ref2]);
     });
 
+    // Test for https://github.com/shaka-project/shaka-player/issues/4185
+    it('does not fail on preload hints with LL mode off', async () => {
+      // LL mode must be off for this test!
+      playerInterface.isLowLatencyMode = () => false;
+
+      const mediaWithPartialSegments = [
+        '#EXTM3U\n',
+        '#EXT-X-TARGETDURATION:5\n',
+        '#EXTINF:4,\n',
+        'main.mp4\n',
+        '#EXT-X-PART:DURATION=2,URI="partial.mp4",BYTERANGE=210@0\n',
+        '#EXT-X-PRELOAD-HINT:TYPE=PART,URI="partial.mp4",BYTERANGE-START=210\n',
+      ].join('');
+
+      fakeNetEngine
+          .setResponseText('test:/master', master)
+          .setResponseText('test:/video', mediaWithPartialSegments);
+
+      // If this throws, the test fails.  Otherwise, it passes.
+      await parser.start('test:/master', playerInterface);
+    });
+
     describe('update', () => {
       it('adds new segments when they appear', async () => {
-        const ref1 = ManifestParser.makeReference('test:/main.mp4', 2, 4);
-        const ref2 = ManifestParser.makeReference('test:/main2.mp4', 4, 6);
+        const ref1 = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null);
+        const ref2 = makeReference(
+            'test:/main2.mp4', 2, 4, /* syncTime= */ null);
 
         await testUpdate(
             master, media, [ref1], mediaWithAdditionalSegment, [ref1, ref2]);
       });
 
       it('evicts removed segments', async () => {
-        const ref1 = ManifestParser.makeReference('test:/main.mp4', 2, 4);
-        const ref2 = ManifestParser.makeReference('test:/main2.mp4', 4, 6);
+        const ref1 = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null);
+        const ref2 = makeReference(
+            'test:/main2.mp4', 2, 4, /* syncTime= */ null);
 
         await testUpdate(
             master, mediaWithAdditionalSegment, [ref1, ref2],
@@ -718,12 +648,13 @@ describe('HlsParser live', () => {
       });
 
       it('handles updates with redirects', async () => {
-        const oldRef1 = ManifestParser.makeReference('test:/main.mp4', 2, 4);
+        const oldRef1 = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null);
 
-        const newRef1 =
-            ManifestParser.makeReference('test:/redirected/main.mp4', 2, 4);
-        const newRef2 =
-            ManifestParser.makeReference('test:/redirected/main2.mp4', 4, 6);
+        const newRef1 = makeReference(
+            'test:/redirected/main.mp4', 0, 2, /* syncTime= */ null);
+        const newRef2 = makeReference(
+            'test:/redirected/main2.mp4', 2, 4, /* syncTime= */ null);
 
         let playlistFetchCount = 0;
 
@@ -750,8 +681,8 @@ describe('HlsParser live', () => {
             .setResponseValue('test:/init.mp4', initSegmentData)
             .setResponseValue('test:/main.mp4', segmentData);
 
-        const expectedRef = ManifestParser.makeReference(
-            'test:/main.mp4', segmentDataStartTime, segmentDataStartTime + 2);
+        const expectedRef = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null);
         // In live content, we do not set timestampOffset.
         expectedRef.timestampOffset = 0;
 
@@ -768,12 +699,11 @@ describe('HlsParser live', () => {
             .setResponseValue('test:/init.mp4', initSegmentData)
             .setResponseValue('test:/main.mp4', segmentData);
 
-        const ref1 = ManifestParser.makeReference(
-            'test:/main.mp4', segmentDataStartTime, segmentDataStartTime + 2);
+        const ref1 = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null);
 
-        const ref2 = ManifestParser.makeReference(
-            'test:/main2.mp4', segmentDataStartTime + 2,
-            segmentDataStartTime + 4);
+        const ref2 = makeReference(
+            'test:/main2.mp4', 2, 4, /* syncTime= */ null);
 
         const manifest = await parser.start('test:/master', playerInterface);
         const video = manifest.variants[0].video;
@@ -809,11 +739,11 @@ describe('HlsParser live', () => {
                 .setResponseValue('test:/main.mp4', segmentData)
                 .setResponseValue('test:/main2.mp4', segmentData);
 
-            const ref1 = ManifestParser.makeReference('test:/main.mp4',
-                segmentDataStartTime, segmentDataStartTime + 2);
+            const ref1 = makeReference(
+                'test:/main.mp4', 0, 2, /* syncTime= */ null);
 
-            const ref2 = ManifestParser.makeReference('test:/main2.mp4',
-                segmentDataStartTime + 2, segmentDataStartTime + 4);
+            const ref2 = makeReference(
+                'test:/main2.mp4', 2, 4, /* syncTime= */ null);
 
             const manifest =
                 await parser.start('test:/master', playerInterface);
@@ -846,57 +776,6 @@ describe('HlsParser live', () => {
                 shaka.net.NetworkingEngine.RequestType.SEGMENT);
           });
 
-      it('parses start time from ts segments', async () => {
-        const tsMediaPlaylist =
-            mediaWithRemovedSegment.replace(/\.mp4/g, '.ts');
-
-        fakeNetEngine
-            .setResponseText('test:/master', master)
-            .setResponseText('test:/video', tsMediaPlaylist)
-            .setResponseValue('test:/main2.ts', tsSegmentData);
-
-        const expectedRef = ManifestParser.makeReference(
-            'test:/main2.ts', segmentDataStartTime, segmentDataStartTime + 2);
-        // In live content, we do not set timestampOffset.
-        expectedRef.timestampOffset = 0;
-
-        const manifest = await parser.start('test:/master', playerInterface);
-        const video = manifest.variants[0].video;
-        await video.createSegmentIndex();
-        ManifestParser.verifySegmentIndex(video, [expectedRef]);
-      });
-
-      it('gets start time of segments with byte range', async () => {
-        // Nit: this value is an implementation detail of the fix for #1106
-        const partialEndByte = expectedStartByte + 2048 - 1;
-
-        fakeNetEngine
-            .setResponseText('test:/master', master)
-            .setResponseText('test:/video', mediaWithByteRange)
-            .setResponseValue('test:/init.mp4', initSegmentData)
-            .setResponseValue('test:/main.mp4', segmentData);
-
-        const expectedRef = ManifestParser.makeReference(
-            /* uri= */ 'test:/main.mp4',
-            /* start= */ segmentDataStartTime,
-            /* end= */ segmentDataStartTime + 2,
-            /* baseUri= */ '',
-            expectedStartByte,
-            expectedEndByte);  // Complete segment reference
-
-        const manifest = await parser.start('test:/master', playerInterface);
-        const video = manifest.variants[0].video;
-        await video.createSegmentIndex();
-        ManifestParser.verifySegmentIndex(video, [expectedRef]);
-
-        // There should have been a range request for this segment to get the
-        // start time.
-        fakeNetEngine.expectRangeRequest(
-            'test:/main.mp4',
-            expectedStartByte,
-            partialEndByte);  // partial segment request
-      });
-
       it('request playlist delta updates to skip segments', async () => {
         const mediaWithDeltaUpdates = [
           '#EXTM3U\n',
@@ -961,9 +840,12 @@ describe('HlsParser live', () => {
         ].join('');
 
         playerInterface.isLowLatencyMode = () => true;
-        const ref1 = ManifestParser.makeReference('test:/main.mp4', 2, 4);
-        const ref2 = ManifestParser.makeReference('test:/main2.mp4', 4, 6);
-        const ref3 = ManifestParser.makeReference('test:/main3.mp4', 6, 8);
+        const ref1 = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null);
+        const ref2 = makeReference(
+            'test:/main2.mp4', 2, 4, /* syncTime= */ null);
+        const ref3 = makeReference(
+            'test:/main3.mp4', 4, 6, /* syncTime= */ null);
         // With 'SKIPPED-SEGMENTS', ref1 is skipped from the playlist,
         // and ref1 should be in the SegmentReferences list.
         // ref3 should be appended to the SegmentReferences list.
@@ -1003,29 +885,29 @@ describe('HlsParser live', () => {
 
         playerInterface.isLowLatencyMode = () => true;
 
-        const ref1 = ManifestParser.makeReference(
-            'test:/main.mp4', segmentDataStartTime, segmentDataStartTime + 2,
+        const ref1 = makeReference(
+            'test:/main.mp4', 0, 2, /* syncTime= */ null,
             /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
             /* timestampOffset= */ 0);
 
         // Expect the timestamp offset to be set for the segment after the
         // EXT-X-DISCONTINUITY tag.
-        const ref2 = ManifestParser.makeReference(
-            'test:/main2.mp4', segmentDataStartTime + 2,
-            segmentDataStartTime + 4, /* baseUri= */ '', /* startByte= */ 0,
-            /* endByte= */ null, /* timestampOffset= */ 2);
+        const ref2 = makeReference(
+            'test:/main2.mp4', 2, 4, /* syncTime= */ null,
+            /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
+            /* timestampOffset= */ 0);
 
         // Expect the timestamp offset to be set for the segment, with the
         // EXT-X-DISCONTINUITY tag skipped in the playlist.
-        const ref3 = ManifestParser.makeReference(
-            'test:/main3.mp4', segmentDataStartTime + 4,
-            segmentDataStartTime + 6, /* baseUri= */ '', /* startByte= */ 0,
-            /* endByte= */ null, /* timestampOffset= */ 2);
+        const ref3 = makeReference(
+            'test:/main3.mp4', 4, 6, /* syncTime= */ null,
+            /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
+            /* timestampOffset= */ 0);
 
-        const ref4 = ManifestParser.makeReference(
-            'test:/main4.mp4', segmentDataStartTime + 6,
-            segmentDataStartTime + 8, /* baseUri= */ '', /* startByte= */ 0,
-            /* endByte= */ null, /* timestampOffset= */ 2);
+        const ref4 = makeReference(
+            'test:/main4.mp4', 6, 8, /* syncTime= */ null,
+            /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
+            /* timestampOffset= */ 0);
 
         // With 'SKIPPED-SEGMENTS', ref1, ref2 are skipped from the playlist,
         // and ref1,ref2 should be in the SegmentReferences list.
@@ -1036,4 +918,23 @@ describe('HlsParser live', () => {
       });
     });  // describe('update')
   });  // describe('playlist type LIVE')
+
+  /**
+   * @param {string} uri A relative URI to http://example.com
+   * @param {number} start
+   * @param {number} end
+   * @param {?number} syncTime
+   * @param {string=} baseUri
+   * @param {number=} startByte
+   * @param {?number=} endByte
+   * @param {number=} timestampOffset
+   * @param {!Array.<!shaka.media.SegmentReference>=} partialReferences
+   * @param {?string=} tilesLayout
+   * @return {!shaka.media.SegmentReference}
+   */
+  function makeReference(uri, start, end, syncTime, baseUri, startByte, endByte,
+      timestampOffset, partialReferences, tilesLayout) {
+    return ManifestParser.makeReference(uri, start, end, baseUri, startByte,
+        endByte, timestampOffset, partialReferences, tilesLayout, syncTime);
+  }
 });  // describe('HlsParser live')