shaka-player 3.3.5 → 4.0.2

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,62 +539,13 @@ 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);
-    });
-
+    // Test for https://github.com/shaka-project/shaka-player/issues/4223
     it('parses streams with partial and preload hinted segments', async () => {
       playerInterface.isLowLatencyMode = () => true;
       const mediaWithPartialSegments = [
         '#EXTM3U\n',
         '#EXT-X-TARGETDURATION:5\n',
+        '#EXT-X-PART-INF:PART-TARGET=1.5\n',
         '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
         '#EXT-X-MEDIA-SEQUENCE:0\n',
         // ref includes partialRef, partialRef2
@@ -661,35 +570,30 @@ 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 ref = makeReference(
+          'test:/main.mp4', 0, 4, /* syncTime= */ null,
+          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 429,
+          /* timestampOffset= */ 0, [partialRef, partialRef2]);
 
-      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, 7.5, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 210, /* endByte= */ null);
 
-      const ref = ManifestParser.makeReference(
-          'test:/main.mp4', segmentDataStartTime, segmentDataStartTime + 4,
-          /* 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, 7.5, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
           /* timestampOffset= */ 0, [partialRef3, preloadRef]);
 
@@ -699,18 +603,23 @@ 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;
+    // Test for https://github.com/shaka-project/shaka-player/issues/4223
+    it('ignores preload hinted segments without target duration', async () => {
+      playerInterface.isLowLatencyMode = () => true;
 
+      // Missing PART-TARGET, so preload hints are skipped.
       const mediaWithPartialSegments = [
         '#EXTM3U\n',
         '#EXT-X-TARGETDURATION:5\n',
         '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+        '#EXT-X-MEDIA-SEQUENCE:0\n',
         '#EXTINF:4,\n',
+        // ref1
         'main.mp4\n',
+        // ref2 includes partialRef, but not preloadRef
+        // partialRef
         '#EXT-X-PART:DURATION=2,URI="partial.mp4",BYTERANGE=210@0\n',
+        // preloadRef
         '#EXT-X-PRELOAD-HINT:TYPE=PART,URI="partial.mp4",BYTERANGE-START=210\n',
       ].join('');
 
@@ -719,7 +628,48 @@ describe('HlsParser live', () => {
           .setResponseText('test:/video', mediaWithPartialSegments)
           .setResponseValue('test:/init.mp4', initSegmentData)
           .setResponseValue('test:/main.mp4', segmentData)
-          .setResponseValue('test:/partial.mp4', segmentData);
+          .setResponseValue('test:/partial.mp4', segmentData)
+          .setResponseValue('test:/partial2.mp4', segmentData);
+
+      const ref = makeReference(
+          'test:/main.mp4', 0, 4, /* syncTime= */ null,
+          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
+          /* timestampOffset= */ 0, []);
+
+      const partialRef = makeReference(
+          'test:/partial.mp4', 4, 6, /* syncTime= */ null,
+          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 209);
+
+      // ref2 is not fully published yet, so it doesn't have a segment uri.
+      const ref2 = makeReference(
+          '', 4, 6, /* syncTime= */ null,
+          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 209,
+          /* timestampOffset= */ 0, [partialRef]);
+
+      const manifest = await parser.start('test:/master', playerInterface);
+      const video = manifest.variants[0].video;
+      await video.createSegmentIndex();
+      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',
+        '#EXT-X-PART-INF:PART-TARGET=1.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);
@@ -727,16 +677,20 @@ 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]);
       });
 
       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],
@@ -744,12 +698,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;
 
@@ -776,8 +731,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;
 
@@ -794,12 +749,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;
@@ -835,11 +789,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);
@@ -872,57 +826,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',
@@ -987,9 +890,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.
@@ -1029,29 +935,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.
@@ -1062,4 +968,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')