shaka-player 4.1.4 → 4.1.6

package/test/hls/hls_parser_unit.js

@@ -91,6 +91,7 @@ describe('HlsParser', () => {
       isLowLatencyMode: () => false,
       isAutoLowLatencyMode: () => false,
       enableLowLatencyMode: () => {},
+      updateDuration: () => {},
     };
 
     parser = new shaka.hls.HlsParser();
@@ -110,6 +111,8 @@ describe('HlsParser', () => {
         .setResponseText('test:/audio2', media)
         .setResponseText('test:/video', media)
         .setResponseText('test:/video2', media)
+        .setResponseText('test:/text', media)
+        .setResponseText('test:/text2', media)
         .setResponseText('test:/main.vtt', vttText)
         .setResponseValue('test:/init.mp4', initSegmentData)
         .setResponseValue('test:/init2.mp4', initSegmentData)
@@ -927,11 +930,14 @@ describe('HlsParser', () => {
       '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1,mp4a",',
       'RESOLUTION=960x540,FRAME-RATE=60,AUDIO="aud1"\n',
       'video\n',
+
       '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="en",',
-      'URI="audio"\n',
+      'NAME="English",URI="audio"\n',
+
       '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="en",',
       'CHARACTERISTICS="public.accessibility.describes-video,',
-      'public.accessibility.describes-music-and-sound",URI="audio2"\n',
+      'public.accessibility.describes-music-and-sound",',
+      'NAME="English (describes-video)",URI="audio2"\n',
     ].join('');
 
     const media = [
@@ -969,6 +975,58 @@ describe('HlsParser', () => {
     await testHlsParser(master, media, manifest);
   });
 
+  it('parses characteristics from text tags', async () => {
+    const master = [
+      '#EXTM3U\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1",',
+      'RESOLUTION=960x540,FRAME-RATE=60,SUBTITLES="sub1"\n',
+      'video\n',
+
+      '#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="sub1",LANGUAGE="en",',
+      'NAME="English (caption)",DEFAULT=YES,AUTOSELECT=YES,',
+      'URI="text"\n',
+
+      '#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="sub1",LANGUAGE="en",',
+      'NAME="English (caption)",DEFAULT=YES,AUTOSELECT=YES,',
+      'CHARACTERISTICS="public.accessibility.describes-spoken-dialog,',
+      'public.accessibility.describes-music-and-sound",',
+      'URI="text2"\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.addPartialStream(ContentType.VIDEO);
+      });
+      manifest.addPartialTextStream((stream) => {
+        stream.language = 'en';
+        stream.kind = TextStreamKind.SUBTITLE;
+        stream.mime('application/mp4', '');
+      });
+      manifest.addPartialTextStream((stream) => {
+        stream.language = 'en';
+        stream.kind = TextStreamKind.SUBTITLE;
+        stream.mime('application/mp4', '');
+        stream.roles = [
+          'public.accessibility.describes-spoken-dialog',
+          'public.accessibility.describes-music-and-sound',
+        ];
+      });
+      manifest.sequenceMode = true;
+    });
+
+    await testHlsParser(master, media, manifest);
+  });
+
   it('gets mime type from header request', async () => {
     const master = [
       '#EXTM3U\n',

package/test/media/drm_engine_unit.js

@@ -1097,6 +1097,14 @@ describe('DrmEngine', () => {
             'encrypted', jasmine.any(Function), jasmine.anything());
       });
 
+      it('is not listened for if parseInbandPsshEnabled is true', async () => {
+        config.parseInbandPsshEnabled = true;
+        drmEngine.configure(config);
+        await initAndAttach();
+        expect(mockVideo.addEventListener).not.toHaveBeenCalledWith(
+            'encrypted', jasmine.any(Function), jasmine.anything());
+      });
+
       it('triggers the creation of a session', async () => {
         await initAndAttach();
         const initData1 = new Uint8Array(1);
@@ -2355,6 +2363,59 @@ describe('DrmEngine', () => {
     }
   });
 
+  describe('parseInbandPssh', () => {
+    const WIDEVINE_PSSH =
+        '00000028' +                          // atom size
+        '70737368' +                          // atom type='pssh'
+        '00000000' +                          // v0, flags=0
+        'edef8ba979d64acea3c827dcd51d21ed' +  // system id (Widevine)
+        '00000008' +                          // data size
+        '0102030405060708';                   // data
+
+    const PLAYREADY_PSSH =
+        '00000028' +                          // atom size
+        '70737368' +                          // atom type 'pssh'
+        '00000000' +                          // v0, flags=0
+        '9a04f07998404286ab92e65be0885f95' +  // system id (PlayReady)
+        '00000008' +                          // data size
+        '0102030405060708';                   // data
+
+    const SEGMENT =
+        '00000058' + // atom size = 28x + 28x + 8x
+        '6d6f6f66' + // atom type 'moof'
+        WIDEVINE_PSSH +
+        PLAYREADY_PSSH;
+
+    const binarySegment = shaka.util.Uint8ArrayUtils.fromHex(SEGMENT);
+
+    it('calls newInitData when enabled', async () => {
+      config.parseInbandPsshEnabled = true;
+      await initAndAttach();
+
+      /** @type {!jasmine.Spy} */
+      const newInitDataSpy = jasmine.createSpy('newInitData');
+      drmEngine.newInitData = shaka.test.Util.spyFunc(newInitDataSpy);
+
+      await drmEngine.parseInbandPssh(
+          shaka.util.ManifestParserUtils.ContentType.VIDEO, binarySegment);
+      const expectedInitData = shaka.util.Uint8ArrayUtils.fromHex(
+          WIDEVINE_PSSH + PLAYREADY_PSSH);
+      expect(newInitDataSpy).toHaveBeenCalledWith('cenc', expectedInitData);
+    });
+
+    it('does not call newInitData when disabled', async () => {
+      config.parseInbandPsshEnabled = false;
+      await initAndAttach();
+
+      /** @type {!jasmine.Spy} */
+      const newInitDataSpy = jasmine.createSpy('newInitData');
+      drmEngine.newInitData = shaka.test.Util.spyFunc(newInitDataSpy);
+      await drmEngine.parseInbandPssh(
+          shaka.util.ManifestParserUtils.ContentType.VIDEO, binarySegment);
+      expect(newInitDataSpy).not.toHaveBeenCalled();
+    });
+  });
+
   async function initAndAttach() {
     const variants = manifest.variants;
     await drmEngine.initForPlayback(variants, manifest.offlineSessionIds);

package/test/media/media_source_engine_integration.js

@@ -380,6 +380,42 @@ describe('MediaSourceEngine', () => {
     expect(textDisplayer.appendSpy).toHaveBeenCalledTimes(3);
   });
 
+  it('buffers partial TS video segments in sequence mode', async () => {
+    metadata = shaka.test.TestScheme.DATA['cea-708_ts'];
+    generators = shaka.test.TestScheme.GENERATORS['cea-708_ts'];
+
+    const videoType = ContentType.VIDEO;
+    const initObject = new Map();
+    initObject.set(videoType, getFakeStream(metadata.video));
+
+    await mediaSourceEngine.init(
+        initObject, /* forceTransmuxTS= */ false, /* sequenceMode= */ true);
+    await mediaSourceEngine.setDuration(presentationDuration);
+    await mediaSourceEngine.setStreamProperties(
+        videoType,
+        /* timestampOffset= */ 0,
+        /* appendWindowStart= */ 0,
+        /* appendWindowEnd= */ Infinity,
+        /* sequenceMode= */ true);
+
+    const segment = generators[videoType].getSegment(0, Date.now() / 1000);
+    const partialSegmentLength = Math.floor(segment.byteLength / 3);
+
+    let partialSegment = shaka.util.BufferUtils.toUint8(
+        segment, /* offset= */ 0, /* length= */ partialSegmentLength);
+    let reference = dummyReference(videoType, 0);
+    await mediaSourceEngine.appendBuffer(
+        videoType, partialSegment, reference, /* hasClosedCaptions= */ false);
+
+    partialSegment = shaka.util.BufferUtils.toUint8(
+        segment,
+        /* offset= */ partialSegmentLength);
+    reference = dummyReference(videoType, 1);
+    await mediaSourceEngine.appendBuffer(
+        videoType, partialSegment, reference, /* hasClosedCaptions= */ false,
+        /* seeked= */ true);
+  });
+
   it('extracts CEA-708 captions from dash', async () => {
     // Load MP4 file with CEA-708 closed captions.
     metadata = shaka.test.TestScheme.DATA['cea-708_mp4'];

package/test/media/media_source_engine_unit.js

@@ -26,7 +26,8 @@ let MockTimeRanges;
  *   timestampOffset: number,
  *   appendWindowEnd: number,
  *   updateend: function(),
- *   error: function()
+ *   error: function(),
+ *   mode: string
  * }}
  */
 let MockSourceBuffer;
@@ -57,6 +58,7 @@ describe('MediaSourceEngine', () => {
   let audioSourceBuffer;
   let videoSourceBuffer;
   let mockVideo;
+
   /** @type {HTMLMediaElement} */
   let video;
   let mockMediaSource;
@@ -622,6 +624,83 @@ describe('MediaSourceEngine', () => {
 
       expect(mockTextEngine.storeAndAppendClosedCaptions).toHaveBeenCalled();
     });
+
+    it('sets timestampOffset on adaptations in sequence mode', async () => {
+      const initObject = new Map();
+      initObject.set(ContentType.VIDEO, fakeVideoStream);
+      videoSourceBuffer.mode = 'sequence';
+
+      await mediaSourceEngine.init(
+          initObject, /* forceTransmuxTS= */ false, /* sequenceMode= */ true);
+
+      expect(videoSourceBuffer.timestampOffset).toBe(0);
+
+      // Mocks appending a segment from a newly adapted variant with a 0.50
+      // second misalignment from the old variant.
+      const reference = dummyReference(0, 1000);
+      reference.startTime = 0.50;
+      const appendVideo = mediaSourceEngine.appendBuffer(
+          ContentType.VIDEO, buffer, reference, /* hasClosedCaptions= */ false,
+          /* seeked= */ false, /* adaptation= */ true);
+      videoSourceBuffer.updateend();
+      await appendVideo;
+
+      expect(videoSourceBuffer.timestampOffset).toBe(0.50);
+    });
+
+    it('calls abort before setting timestampOffset', async () => {
+      const simulateUpdate = async () => {
+        await Util.shortDelay();
+        videoSourceBuffer.updateend();
+      };
+      const initObject = new Map();
+      initObject.set(ContentType.VIDEO, fakeVideoStream);
+
+      await mediaSourceEngine.init(
+          initObject, /* forceTransmuxTS= */ false, /* sequenceMode= */ true);
+
+      // First, mock the scenario where timestampOffset is set to help align
+      // text segments. In this case, SourceBuffer mode is still 'segments'.
+      let reference = dummyReference(0, 1000);
+      let appendVideo = mediaSourceEngine.appendBuffer(
+          ContentType.VIDEO, buffer, reference, /* hasClosedCaptions= */ false);
+      // Wait for the first appendBuffer(), in segments mode.
+      await simulateUpdate();
+      // Next, wait for abort(), used to reset the parser state for a safe
+      // setting of timestampOffset. Shaka fakes an updateend event on abort(),
+      // so simulateUpdate() isn't needed.
+      await Util.shortDelay();
+      // Next, wait for remove(), used to clear the SourceBuffer from the
+      // initial append.
+      await simulateUpdate();
+      // Next, wait for the second appendBuffer(), falling through to normal
+      // operations.
+      await simulateUpdate();
+      // Lastly, wait for the function-scoped MediaSourceEngine#appendBuffer()
+      // promise to resolve.
+      await appendVideo;
+      expect(videoSourceBuffer.abort).toHaveBeenCalledTimes(1);
+
+      // Second, mock the scenario where timestampOffset is set during an
+      // unbuffered seek or adaptation. SourceBuffer mode is 'sequence' now.
+      reference = dummyReference(0, 1000);
+      appendVideo = mediaSourceEngine.appendBuffer(
+          ContentType.VIDEO, buffer, reference, /* hasClosedCaptions= */ false,
+          /* seeked= */ true);
+      // First, wait for abort(), used to reset the parser state for a safe
+      // setting of timestampOffset.
+      await Util.shortDelay();
+      // The subsequent setTimestampOffset() fakes an updateend event for us, so
+      // simulateUpdate() isn't needed.
+      await Util.shortDelay();
+      // Next, wait for the second appendBuffer(), falling through to normal
+      // operations.
+      await simulateUpdate();
+      // Lastly, wait for the function-scoped MediaSourceEngine#appendBuffer()
+      // promise to resolve.
+      await appendVideo;
+      expect(videoSourceBuffer.abort).toHaveBeenCalledTimes(2);
+    });
   });
 
   describe('remove', () => {
@@ -1003,6 +1082,43 @@ describe('MediaSourceEngine', () => {
       expect(audioSourceBuffer.appendBuffer).toHaveBeenCalledWith(buffer);
       audioSourceBuffer.updateend();
     });
+
+    it('allows duration to be shrunk', async () => {
+      // Pretend the initial duration was 100.
+      mockMediaSource.durationGetter.and.returnValue(100);
+
+      // When duration is shrunk, 'updateend' events are generated.  This is
+      // because reducing the duration triggers the MSE removal algorithm to
+      // run.
+      mockMediaSource.durationSetter.and.callFake((duration) => {
+        expect(duration).toBe(50);
+        videoSourceBuffer.updateend();
+        audioSourceBuffer.updateend();
+      });
+
+      audioSourceBuffer.appendBuffer.and.callFake(() => {
+        audioSourceBuffer.updateend();
+      });
+      videoSourceBuffer.appendBuffer.and.callFake(() => {
+        videoSourceBuffer.updateend();
+      });
+
+      /** @type {!Promise} */
+      const p1 = mediaSourceEngine.setDuration(50);
+      expect(mockMediaSource.durationSetter).not.toHaveBeenCalled();
+
+      // These operations should be blocked until after duration is shrunk.
+      // This is tested because shrinking duration generates 'updateend'
+      // events, and we want to show that the queue still operates correctly.
+      const a1 = mediaSourceEngine.appendBuffer(ContentType.AUDIO, buffer, null,
+          /* hasClosedCaptions= */ false);
+      const a2 = mediaSourceEngine.appendBuffer(ContentType.VIDEO, buffer, null,
+          /* hasClosedCaptions= */ false);
+
+      await p1;
+      await a1;
+      await a2;
+    });
   });
 
   describe('destroy', () => {
@@ -1160,6 +1276,7 @@ describe('MediaSourceEngine', () => {
       appendWindowEnd: Infinity,
       updateend: () => {},
       error: () => {},
+      mode: 'segments',
     };
   }
 

package/test/media/streaming_engine_integration.js

@@ -90,17 +90,17 @@ describe('StreamingEngine', () => {
 
     segmentAvailability = {
       start: 0,
-      end: 60,
+      end: 40,
     };
 
     timeline = shaka.test.StreamingEngineUtil.createFakePresentationTimeline(
         segmentAvailability,
-        /* presentationDuration= */ 60,
+        /* presentationDuration= */ 40,
         /* maxSegmentDuration= */ metadata.video.segmentDuration,
         /* isLive= */ false);
 
     setupNetworkingEngine(
-        /* presentationDuration= */ 60,
+        /* presentationDuration= */ 40,
         {
           audio: metadata.audio.segmentDuration,
           video: metadata.video.segmentDuration,
@@ -108,8 +108,8 @@ describe('StreamingEngine', () => {
 
     setupManifest(
         /* firstPeriodStartTime= */ 0,
-        /* secondPeriodStartTime= */ 30,
-        /* presentationDuration= */ 60);
+        /* secondPeriodStartTime= */ 20,
+        /* presentationDuration= */ 40);
 
     setupPlayhead();
 
@@ -247,6 +247,7 @@ describe('StreamingEngine', () => {
       onManifestUpdate: () => {},
       onSegmentAppended: () => playhead.notifyOfBufferingChange(),
       onInitSegmentAppended: () => {},
+      beforeAppendSegment: () => Promise.resolve(),
     };
     streamingEngine = new shaka.media.StreamingEngine(
         /** @type {shaka.extern.Manifest} */(manifest), playerInterface);
@@ -263,10 +264,11 @@ describe('StreamingEngine', () => {
       streamingEngine.switchVariant(variant);
       await streamingEngine.start();
       video.play();
-      // The overall test timeout is 120 seconds, and the content is 60
+      // The overall test timeout is 120 seconds, and the content is 40
       // seconds.  It should be possible to complete this test in 100 seconds,
       // and if not, we want the error thrown to be within the overall test's
-      // timeout window.
+      // timeout window.  Note that we have seen some devices fail to play at
+      // full speed for reasons beyond our control, so we plan for >= 0.5x.
       await waiter.timeoutAfter(100).waitForEnd(video);
     });
 

package/test/media/streaming_engine_unit.js

@@ -72,6 +72,8 @@ describe('StreamingEngine', () => {
   let getBandwidthEstimate;
   /** @type {!shaka.media.StreamingEngine} */
   let streamingEngine;
+  /** @type {!jasmine.Spy} */
+  let beforeAppendSegment;
 
   /** @type {function(function(), number)} */
   let realSetTimeout;
@@ -418,9 +420,14 @@ describe('StreamingEngine', () => {
     onEvent = jasmine.createSpy('onEvent');
     onManifestUpdate = jasmine.createSpy('onManifestUpdate');
     onSegmentAppended = jasmine.createSpy('onSegmentAppended');
+    beforeAppendSegment = jasmine.createSpy('beforeAppendSegment');
     getBandwidthEstimate = jasmine.createSpy('getBandwidthEstimate');
     getBandwidthEstimate.and.returnValue(1e3);
 
+    beforeAppendSegment.and.callFake((segment) => {
+      return Promise.resolve();
+    });
+
     if (!config) {
       config = shaka.util.PlayerConfiguration.createDefault().streaming;
       config.rebufferingGoal = 2;
@@ -442,6 +449,7 @@ describe('StreamingEngine', () => {
       onManifestUpdate: Util.spyFunc(onManifestUpdate),
       onSegmentAppended: Util.spyFunc(onSegmentAppended),
       onInitSegmentAppended: () => {},
+      beforeAppendSegment: Util.spyFunc(beforeAppendSegment),
     };
     streamingEngine = new shaka.media.StreamingEngine(
         /** @type {shaka.extern.Manifest} */(manifest), playerInterface);
@@ -3472,6 +3480,27 @@ describe('StreamingEngine', () => {
     });
   });
 
+  describe('beforeAppendSegment', () => {
+    it('is called before appending media segment', async () => {
+      setupVod();
+      mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
+      createStreamingEngine();
+      beforeAppendSegment.and.callFake((segment) => {
+        return shaka.test.Util.shortDelay();
+      });
+      streamingEngine.switchVariant(variant);
+      streamingEngine.switchTextStream(textStream);
+      await streamingEngine.start();
+      // Simulate time passing.
+      playing = true;
+      await Util.fakeEventLoop(10);
+      expect(beforeAppendSegment).toHaveBeenCalledWith(
+          ContentType.AUDIO, segmentData[ContentType.AUDIO].initSegments[0]);
+      expect(beforeAppendSegment).toHaveBeenCalledWith(
+          ContentType.AUDIO, segmentData[ContentType.AUDIO].segments[0]);
+    });
+  });
+
   /**
    * Slides the segment availability window forward by 1 second.
    */

package/test/offline/offline_integration.js

@@ -68,7 +68,7 @@ filterDescribe('Offline', supportsStorage, () => {
     await player.load(contentUri);
 
     video.play();
-    await playTo(/* end= */ 3, /* timeout= */ 10);
+    await playTo(/* end= */ 3, /* timeout= */ 20);
     await player.unload();
     await storage.remove(contentUri);
   });
@@ -104,7 +104,7 @@ filterDescribe('Offline', supportsStorage, () => {
         await player.load(contentUri);
 
         video.play();
-        await playTo(/* end= */ 3, /* timeout= */ 10);
+        await playTo(/* end= */ 3, /* timeout= */ 20);
         await player.unload();
         await storage.remove(contentUri);
       });
@@ -147,7 +147,7 @@ filterDescribe('Offline', supportsStorage, () => {
         await player.load(contentUri);
 
         video.play();
-        await playTo(/* end= */ 3, /* timeout= */ 10);
+        await playTo(/* end= */ 3, /* timeout= */ 20);
         await player.unload();
         await storage.remove(contentUri);
       });

package/test/offline/storage_integration.js

@@ -1034,6 +1034,36 @@ filterDescribe('Storage', storageSupport, () => {
       }
     });
 
+    /**
+     * In some situations, indexedDB.open() can just hang, and call neither the
+     * 'success' nor the 'error' callbacks.
+     * I'm not sure what causes it, but it seems to happen consistently between
+     * reloads when it does so it might be a browser-based issue.
+     * In that case, we should time out with an error, instead of also hanging.
+     */
+    it('throws an error if indexedDB open times out', async () => {
+      const oldOpen = window.indexedDB.open;
+      window.indexedDB.open = () => {
+        // Just return a dummy object.
+        return /** @type {!IDBOpenDBRequest} */ ({
+          onsuccess: (event) => {},
+          onerror: (error) => {},
+        });
+      };
+
+      /** @type {!shaka.offline.StorageMuxer} */
+      const muxer = new shaka.offline.StorageMuxer();
+      const expectedError = shaka.test.Util.jasmineError(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.STORAGE,
+          shaka.util.Error.Code.INDEXED_DB_INIT_TIMED_OUT));
+
+      await expectAsync(muxer.init())
+          .toBeRejectedWith(expectedError);
+
+      window.indexedDB.open = oldOpen;
+    });
+
     it('throws an error if the content is a live stream', async () => {
       const expected = Util.jasmineError(new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,

package/test/player_integration.js

@@ -434,7 +434,7 @@ describe('Player', () => {
       // Seek the video, and see if it can continue playing from that point.
       video.currentTime = 20;
       // Expect that we can then reach the end of the video.
-      await waiter.timeoutAfter(20).waitForEnd(video);
+      await waiter.timeoutAfter(40).waitForEnd(video);
     });
 
     // Regression test for #2326.
@@ -785,7 +785,7 @@ describe('Player', () => {
       /** @type {shaka.test.Waiter} */
       const waiter = new shaka.test.Waiter(eventManager)
           .setPlayer(player)
-          .timeoutAfter(20)
+          .timeoutAfter(40)
           .failOnTimeout(true);
       await waiter.waitForEnd(video);
 

package/test/test/util/dash_parser_util.js

@@ -43,6 +43,7 @@ shaka.test.Dash = class {
       isLowLatencyMode: () => false,
       isAutoLowLatencyMode: () => false,
       enableLowLatencyMode: () => {},
+      updateDuration: () => {},
     };
     const manifest = await dashParser.start('dummy://foo', playerInterface);
     const stream = manifest.variants[0].video;
@@ -77,6 +78,7 @@ shaka.test.Dash = class {
       isLowLatencyMode: () => false,
       isAutoLowLatencyMode: () => false,
       enableLowLatencyMode: () => {},
+      updateDuration: () => {},
     };
     const p = dashParser.start('dummy://foo', playerInterface);
     await expectAsync(p).toBeRejectedWith(

package/test/test/util/ttml_utils.js

@@ -51,8 +51,6 @@ shaka.test.TtmlUtils = class {
         region,
         nestedCues: jasmine.any(Object),
         payload: '',
-        startTime: 0,
-        endTime: Infinity,
         isContainer: true,
       });
       Object.assign(containerCue, properties);

package/test/text/ttml_text_parser_unit.js

@@ -1535,6 +1535,52 @@ describe('TtmlTextParser', () => {
         {startTime: 1, endTime: 2});
   });
 
+  // Regression test for #4468
+  it('defaults the body background to transparent', () => {
+    verifyHelper(
+        // One cue, don't care about the details
+        [{}],
+        '<tt xmlns:tts="http://www.w3.org/ns/ttml#styling">' +
+        '<head>' +
+        '<styling>' +
+        '<style xml:id="s1" tts:backgroundColor="black" />' +
+        '</styling>' +
+        '</head>' +
+        '<body><div>' +
+        '<p begin="00:01.00" end="00:02.00">' +
+        '<span style="s1">Test</span>' +
+        '</p>' +
+        '</div></body></tt>',
+        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0},
+        // The body must have these properties:
+        {backgroundColor: 'transparent'},
+        // The div must have these properties:
+        {});  // don't care
+  });
+
+  // Regression test for #4468
+  it('allows the body background color to be set', () => {
+    verifyHelper(
+        // One cue, don't care about the details
+        [{}],
+        '<tt xmlns:tts="http://www.w3.org/ns/ttml#styling">' +
+        '<head>' +
+        '<styling>' +
+        '<style xml:id="s1" tts:backgroundColor="black" />' +
+        '</styling>' +
+        '</head>' +
+        '<body style="s1"><div>' +
+        '<p begin="00:01.00" end="00:02.00">' +
+        '<span>Test</span>' +
+        '</p>' +
+        '</div></body></tt>',
+        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0},
+        // The body must have these properties:
+        {backgroundColor: 'black'},
+        // The div must have these properties:
+        {});  // don't care
+  });
+
   it('parses wrapping option', () => {
     verifyHelper(
         [

package/test/text/vtt_text_parser_unit.js

@@ -597,7 +597,7 @@ describe('VttTextParser', () => {
         [
           {startTime: 95443, endTime: 95445, payload: 'Test'},
         ],
-        // 8589870000/900000 = 95443 sec, so expect every timestamp to be 95443
+        // 8589870000/90000 = 95443 sec, so expect every timestamp to be 95443
         // seconds ahead of what is specified.
         'WEBVTT\n' +
         'X-TIMESTAMP-MAP=MPEGTS:8589870000,LOCAL:00:00:00.000\n\n' +
@@ -623,6 +623,28 @@ describe('VttTextParser', () => {
         /* sequenceMode= */ true);
   });
 
+  // A mock-up of HLS live subs as seen in b/253104251.
+  it('handles timestamp rollover and negative offset in HLS live', () => {
+    // Similar to values seen in b/253104251, for a realistic regression test.
+    // When using sequence mode on live HLS, we get negative offsets that
+    // represent the timestamp of our first append in sequence mode.
+    verifyHelper(
+        [
+          {startTime: 3600, endTime: 3602, payload: 'Test'},
+        ],
+        'WEBVTT\n' +
+        'X-TIMESTAMP-MAP=MPEGTS:8355814896,LOCAL:00:00:00.000\n\n' +
+        '00:00:00.000 --> 00:00:02.000 line:0\n' +
+        'Test',
+        {
+          periodStart: -1234567,
+          segmentStart: 3600,
+          segmentEnd: 3610,
+          vttOffset: -1234567,
+        },
+        /* sequenceMode= */ true);
+  });
+
   it('supports global style blocks', () => {
     const textShadow = '-1px 0 black, 0 1px black, 1px 0 black, 0 -1px black';
     verifyHelper(