shaka-player 3.3.0 → 3.3.1

package/test/media/streaming_engine_unit.js

@@ -97,6 +97,9 @@ describe('StreamingEngine', () => {
   /** @type {!shaka.media.StreamingEngine} */
   let streamingEngine;
 
+  /** @type {function(function(), number)} */
+  let realSetTimeout;
+
   /**
    * Runs the fake event loop.
    * @param {function()=} callback An optional callback that is executed
@@ -116,6 +119,7 @@ describe('StreamingEngine', () => {
   }
 
   beforeAll(() => {
+    realSetTimeout = window.setTimeout;
     jasmine.clock().install();
     jasmine.clock().mockDate();
   });
@@ -824,6 +828,53 @@ describe('StreamingEngine', () => {
         .toHaveBeenCalledWith('video', 0, lt20, gt40);
   });
 
+  // Regression test for https://github.com/google/shaka-player/issues/3717
+  it('applies fudge factors for the duration', async () => {
+    setupVod();
+
+    // In #3717, the duration was just barely large enough to encompass an
+    // additional segment, but that segment didn't exist, so playback never
+    // completed.  Here, we set the duration to just beyond the 3rd segment, and
+    // we make the 4th segment fail when requested.
+    const duration = 30.000000005;
+    timeline.getDuration.and.returnValue(duration);
+
+    const targetUri = '1_video_3';  // The URI of the 4th video segment.
+    failRequestsForTarget(netEngine, targetUri);
+
+    mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
+    createStreamingEngine();
+
+    // Here we go!
+    streamingEngine.switchVariant(variant);
+    streamingEngine.switchTextStream(textStream);
+    await streamingEngine.start();
+    playing = true;
+    await runTest();
+
+    // The end of the stream should have been reached, and the 4th segment from
+    // each type should never have been requested.
+    expect(mediaSourceEngine.endOfStream).toHaveBeenCalled();
+
+    const segmentType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
+
+    netEngine.expectRequest('0_audio_0', segmentType);
+    netEngine.expectRequest('0_video_0', segmentType);
+    netEngine.expectRequest('0_text_0', segmentType);
+
+    netEngine.expectRequest('0_audio_1', segmentType);
+    netEngine.expectRequest('0_video_1', segmentType);
+    netEngine.expectRequest('0_text_1', segmentType);
+
+    netEngine.expectRequest('1_audio_2', segmentType);
+    netEngine.expectRequest('1_video_2', segmentType);
+    netEngine.expectRequest('1_text_2', segmentType);
+
+    netEngine.expectNoRequest('1_audio_3', segmentType);
+    netEngine.expectNoRequest('1_video_3', segmentType);
+    netEngine.expectNoRequest('1_text_3', segmentType);
+  });
+
   it('does not buffer one media type ahead of another', async () => {
     setupVod();
     mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
@@ -1391,6 +1442,66 @@ describe('StreamingEngine', () => {
       });
     });
 
+    it('into unbuffered regions when nothing is buffered ' +
+      'and mediaState is performing an update', async () => {
+      // Here we go!
+      streamingEngine.switchVariant(variant);
+      streamingEngine.switchTextStream(textStream);
+      // ensure init source buffer promise does not resolve before seeked()
+      // so mediaState remains in "performingUpdate" state
+      const initSourceBufferPromise = new shaka.util.PublicPromise();
+      mediaSourceEngine.setStreamProperties.and
+          .returnValue(initSourceBufferPromise);
+      await streamingEngine.start();
+      playing = true;
+
+      // tick to trigger mediaState updates
+      jasmine.clock().tick(1);
+      // give a chance for fetchAndAppend_ to be invoked
+      // by async onUpdate_ callback
+      await Util.shortDelay(realSetTimeout);
+
+      // Nothing is buffered yet.
+      expect(mediaSourceEngine.segments).toEqual({
+        audio: [false, false, false, false],
+        video: [false, false, false, false],
+        text: [false, false, false, false],
+      });
+
+      // Seek forward to an unbuffered region in the first Period.
+      presentationTimeInSeconds = 15;
+      streamingEngine.seeked();
+
+      // resolve initSourceBufferPromise after seeked(), waitingToClearBuffer
+      // should have been set, so this will now trigger the actual flush of
+      // the buffer
+      initSourceBufferPromise.resolve();
+      mediaSourceEngine.setStreamProperties.and
+          .returnValue(Promise.resolve());
+
+      // allow mediaState update to resolve
+      await Util.shortDelay(realSetTimeout);
+
+      onTick.and.callFake(() => {
+        expect(mediaSourceEngine.clear).toHaveBeenCalled();
+        onTick.and.stub();
+      });
+
+      await runTest(Util.spyFunc(onTick));
+
+      // Verify buffers.
+      expect(mediaSourceEngine.initSegments).toEqual({
+        audio: [false, true],
+        video: [false, true],
+        text: [],
+      });
+      expect(mediaSourceEngine.segments).toEqual({
+        audio: [false, true, true, true],
+        video: [false, true, true, true],
+        text: [false, true, true, true],
+      });
+    });
+
     it('into unbuffered regions near segment start', async () => {
       // Here we go!
       streamingEngine.switchVariant(variant);
@@ -3390,6 +3501,40 @@ describe('StreamingEngine', () => {
     segmentAvailability.end++;
   }
 
+  /**
+   * @param {!shaka.test.FakeNetworkingEngine} netEngine A NetworkingEngine
+   *   look-alike.
+   * @param {string} targetUri
+   * @param {shaka.util.Error.Code=} errorCode
+   */
+  function failRequestsForTarget(
+      netEngine, targetUri, errorCode=shaka.util.Error.Code.BAD_HTTP_STATUS) {
+    // eslint-disable-next-line no-restricted-syntax
+    const originalNetEngineRequest = netEngine.request.bind(netEngine);
+
+    netEngine.request = jasmine.createSpy('request').and.callFake(
+        (requestType, request) => {
+          if (request.uris[0] == targetUri) {
+            const data = [targetUri];
+
+            if (errorCode == shaka.util.Error.Code.BAD_HTTP_STATUS) {
+              data.push(404);
+              data.push('');
+            }
+
+            // The compiler still sees the error code parameter as potentially
+            // undefined, even though we gave it a default value.
+            goog.asserts.assert(errorCode != undefined, 'Undefined error code');
+
+            return shaka.util.AbortableOperation.failed(new shaka.util.Error(
+                shaka.util.Error.Severity.CRITICAL,
+                shaka.util.Error.Category.NETWORK,
+                errorCode, data));
+          }
+          return originalNetEngineRequest(requestType, request);
+        });
+  }
+
   /**
    * @param {!shaka.test.FakeNetworkingEngine} netEngine A NetworkingEngine
    *   look-alike.

package/test/player_integration.js

@@ -1063,9 +1063,9 @@ describe('Player', () => {
     it('add external chapters in vtt format', async () => {
       await player.load('test:sintel_no_text_compiled');
       const locationUri = new goog.Uri(location.href);
-      const partialUri = new goog.Uri('/base/test/test/assets/chapters.vtt');
-      const absoluteUri = locationUri.resolve(partialUri);
-      await player.addChaptersTrack(absoluteUri.toString(), 'en');
+      const partialUri1 = new goog.Uri('/base/test/test/assets/chapters.vtt');
+      const absoluteUri1 = locationUri.resolve(partialUri1);
+      await player.addChaptersTrack(absoluteUri1.toString(), 'en');
 
       await shaka.test.Util.delay(1.5);
 
@@ -1078,11 +1078,44 @@ describe('Player', () => {
       const chapter2 = chapters[1];
       expect(chapter2.title).toBe('Chapter 2');
       expect(chapter2.startTime).toBe(5);
-      expect(chapter2.endTime).toBe(30);
+      expect(chapter2.endTime).toBe(10);
       const chapter3 = chapters[2];
       expect(chapter3.title).toBe('Chapter 3');
-      expect(chapter3.startTime).toBe(30);
-      expect(chapter3.endTime).toBe(61.349);
+      expect(chapter3.startTime).toBe(10);
+      expect(chapter3.endTime).toBe(20);
+
+      const partialUri2 = new goog.Uri('/base/test/test/assets/chapters2.vtt');
+      const absoluteUri2 = locationUri.resolve(partialUri2);
+      await player.addChaptersTrack(absoluteUri2.toString(), 'en');
+
+      await shaka.test.Util.delay(1.5);
+
+      const chaptersUpdated = player.getChapters('en');
+      expect(chaptersUpdated.length).toBe(6);
+      const chapterUpdated1 = chaptersUpdated[0];
+      expect(chapterUpdated1.title).toBe('Chapter 1');
+      expect(chapterUpdated1.startTime).toBe(0);
+      expect(chapterUpdated1.endTime).toBe(5);
+      const chapterUpdated2 = chaptersUpdated[1];
+      expect(chapterUpdated2.title).toBe('Chapter 2');
+      expect(chapterUpdated2.startTime).toBe(5);
+      expect(chapterUpdated2.endTime).toBe(10);
+      const chapterUpdated3 = chaptersUpdated[2];
+      expect(chapterUpdated3.title).toBe('Chapter 3');
+      expect(chapterUpdated3.startTime).toBe(10);
+      expect(chapterUpdated3.endTime).toBe(20);
+      const chapterUpdated4 = chaptersUpdated[3];
+      expect(chapterUpdated4.title).toBe('Chapter 4');
+      expect(chapterUpdated4.startTime).toBe(20);
+      expect(chapterUpdated4.endTime).toBe(30);
+      const chapterUpdated5 = chaptersUpdated[4];
+      expect(chapterUpdated5.title).toBe('Chapter 5');
+      expect(chapterUpdated5.startTime).toBe(30);
+      expect(chapterUpdated5.endTime).toBe(40);
+      const chapterUpdated6 = chaptersUpdated[5];
+      expect(chapterUpdated6.title).toBe('Chapter 6');
+      expect(chapterUpdated6.startTime).toBe(40);
+      expect(chapterUpdated6.endTime).toBe(61.349);
     });
 
     it('add external chapters in srt format', async () => {
@@ -1090,11 +1123,11 @@ describe('Player', () => {
       const locationUri = new goog.Uri(location.href);
       const partialUri = new goog.Uri('/base/test/test/assets/chapters.srt');
       const absoluteUri = locationUri.resolve(partialUri);
-      await player.addChaptersTrack(absoluteUri.toString(), 'en');
+      await player.addChaptersTrack(absoluteUri.toString(), 'es');
 
       await shaka.test.Util.delay(1.5);
 
-      const chapters = player.getChapters('en');
+      const chapters = player.getChapters('es');
       expect(chapters.length).toBe(3);
       const chapter1 = chapters[0];
       expect(chapter1.title).toBe('Chapter 1');

package/test/player_src_equals_integration.js

@@ -330,9 +330,9 @@ describe('Player Src Equals', () => {
     await loadWithSrcEquals(SMALL_MP4_CONTENT_URI, /* startTime= */ null);
 
     const locationUri = new goog.Uri(location.href);
-    const partialUri = new goog.Uri('/base/test/test/assets/chapters.vtt');
-    const absoluteUri = locationUri.resolve(partialUri);
-    await player.addChaptersTrack(absoluteUri.toString(), 'en');
+    const partialUri1 = new goog.Uri('/base/test/test/assets/chapters.vtt');
+    const absoluteUri1 = locationUri.resolve(partialUri1);
+    await player.addChaptersTrack(absoluteUri1.toString(), 'en');
 
     await shaka.test.Util.delay(1.5);
 
@@ -345,11 +345,44 @@ describe('Player Src Equals', () => {
     const chapter2 = chapters[1];
     expect(chapter2.title).toBe('Chapter 2');
     expect(chapter2.startTime).toBe(5);
-    expect(chapter2.endTime).toBe(30);
+    expect(chapter2.endTime).toBe(10);
     const chapter3 = chapters[2];
     expect(chapter3.title).toBe('Chapter 3');
-    expect(chapter3.startTime).toBe(30);
-    expect(chapter3.endTime).toBe(61.349);
+    expect(chapter3.startTime).toBe(10);
+    expect(chapter3.endTime).toBe(20);
+
+    const partialUri2 = new goog.Uri('/base/test/test/assets/chapters2.vtt');
+    const absoluteUri2 = locationUri.resolve(partialUri2);
+    await player.addChaptersTrack(absoluteUri2.toString(), 'en');
+
+    await shaka.test.Util.delay(1.5);
+
+    const chaptersUpdated = player.getChapters('en');
+    expect(chaptersUpdated.length).toBe(6);
+    const chapterUpdated1 = chaptersUpdated[0];
+    expect(chapterUpdated1.title).toBe('Chapter 1');
+    expect(chapterUpdated1.startTime).toBe(0);
+    expect(chapterUpdated1.endTime).toBe(5);
+    const chapterUpdated2 = chaptersUpdated[1];
+    expect(chapterUpdated2.title).toBe('Chapter 2');
+    expect(chapterUpdated2.startTime).toBe(5);
+    expect(chapterUpdated2.endTime).toBe(10);
+    const chapterUpdated3 = chaptersUpdated[2];
+    expect(chapterUpdated3.title).toBe('Chapter 3');
+    expect(chapterUpdated3.startTime).toBe(10);
+    expect(chapterUpdated3.endTime).toBe(20);
+    const chapterUpdated4 = chaptersUpdated[3];
+    expect(chapterUpdated4.title).toBe('Chapter 4');
+    expect(chapterUpdated4.startTime).toBe(20);
+    expect(chapterUpdated4.endTime).toBe(30);
+    const chapterUpdated5 = chaptersUpdated[4];
+    expect(chapterUpdated5.title).toBe('Chapter 5');
+    expect(chapterUpdated5.startTime).toBe(30);
+    expect(chapterUpdated5.endTime).toBe(40);
+    const chapterUpdated6 = chaptersUpdated[5];
+    expect(chapterUpdated6.title).toBe('Chapter 6');
+    expect(chapterUpdated6.startTime).toBe(40);
+    expect(chapterUpdated6.endTime).toBe(61.349);
   });
 
   it('add external chapters in srt format', async () => {
@@ -358,11 +391,11 @@ describe('Player Src Equals', () => {
     const locationUri = new goog.Uri(location.href);
     const partialUri = new goog.Uri('/base/test/test/assets/chapters.srt');
     const absoluteUri = locationUri.resolve(partialUri);
-    await player.addChaptersTrack(absoluteUri.toString(), 'en');
+    await player.addChaptersTrack(absoluteUri.toString(), 'es');
 
     await shaka.test.Util.delay(1.5);
 
-    const chapters = player.getChapters('en');
+    const chapters = player.getChapters('es');
     expect(chapters.length).toBe(3);
     const chapter1 = chapters[0];
     expect(chapter1.title).toBe('Chapter 1');

package/test/player_unit.js

@@ -36,7 +36,7 @@ describe('Player', () => {
   const originalLogWarn = shaka.log.warning;
   const originalLogAlwaysWarn = shaka.log.alwaysWarn;
   const originalIsTypeSupported = window.MediaSource.isTypeSupported;
-  const originalDecodingInfo = window.shakaMediaCapabilities.decodingInfo;
+  const originalDecodingInfo = navigator.mediaCapabilities.decodingInfo;
 
   const fakeManifestUri = 'fake-manifest-uri';
   const fakeMimeType = 'application/test';
@@ -93,7 +93,7 @@ describe('Player', () => {
     // Since this is not an integration test, we don't want MediaCapabilities to
     // fail assertions based on browser support for types.  Pretend that all
     // video and audio types are supported.
-    window.shakaMediaCapabilities.decodingInfo = async (config) => {
+    navigator.mediaCapabilities.decodingInfo = async (config) => {
       await Promise.resolve();
       const videoType = config['video'] ?
           config['video'].contentType.split('/')[0] : null;
@@ -177,7 +177,7 @@ describe('Player', () => {
       shaka.log.alwaysWarn = originalLogAlwaysWarn;
       window.MediaSource.isTypeSupported = originalIsTypeSupported;
       shaka.media.ManifestParser.unregisterParserByMime(fakeMimeType);
-      window.shakaMediaCapabilities.decodingInfo = originalDecodingInfo;
+      navigator.mediaCapabilities.decodingInfo = originalDecodingInfo;
     }
   });
 
@@ -1092,8 +1092,8 @@ describe('Player', () => {
         // Image tracks
         manifest.addImageStream(53, (stream) => {
           stream.originalId = 'thumbnail';
-          stream.width = 100;
-          stream.height = 200;
+          stream.width = 200;
+          stream.height = 400;
           stream.bandwidth = 10;
           stream.mimeType = 'image/jpeg';
           stream.tilesLayout = '1x1';
@@ -1503,8 +1503,8 @@ describe('Player', () => {
           audioBandwidth: null,
           videoBandwidth: null,
           bandwidth: 10,
-          width: 100,
-          height: 200,
+          width: 200,
+          height: 400,
           frameRate: null,
           pixelAspectRatio: null,
           hdr: null,
@@ -2463,7 +2463,7 @@ describe('Player', () => {
     it('throws CONTENT_UNSUPPORTED_BY_BROWSER', async () => {
       window.MediaSource.isTypeSupported = (mimeType) => false;
 
-      window.shakaMediaCapabilities.decodingInfo = async (config) => {
+      navigator.mediaCapabilities.decodingInfo = async (config) => {
         await Promise.resolve();
         return {supported: false};
       };
@@ -2827,7 +2827,7 @@ describe('Player', () => {
         });
       });
 
-      window.shakaMediaCapabilities.decodingInfo = async (config) => {
+      navigator.mediaCapabilities.decodingInfo = async (config) => {
         await Promise.resolve();
         const videoType = config['video'] ? config['video'].contentType : '';
         if (videoType.includes('video') &&
@@ -3537,29 +3537,39 @@ describe('Player', () => {
 
         await player.load(fakeManifestUri, 0, fakeMimeType);
 
+        expect(player.getImageTracks()[0].width).toBe(100);
+        expect(player.getImageTracks()[0].height).toBe(50);
         const thumbnail0 = await player.getThumbnails(5, 0);
         const thumbnail1 = await player.getThumbnails(5, 11);
         const thumbnail2 = await player.getThumbnails(5, 21);
         const thumbnail5 = await player.getThumbnails(5, 51);
         expect(thumbnail0).toEqual(jasmine.objectContaining({
+          imageHeight: 150,
+          imageWidth: 200,
           positionX: 0,
           positionY: 0,
           width: 100,
           height: 50,
         }));
         expect(thumbnail1).toEqual(jasmine.objectContaining({
+          imageHeight: 150,
+          imageWidth: 200,
           positionX: 100,
           positionY: 0,
           width: 100,
           height: 50,
         }));
         expect(thumbnail2).toEqual(jasmine.objectContaining({
+          imageHeight: 150,
+          imageWidth: 200,
           positionX: 0,
           positionY: 50,
           width: 100,
           height: 50,
         }));
         expect(thumbnail5).toEqual(jasmine.objectContaining({
+          imageHeight: 150,
+          imageWidth: 200,
           positionX: 100,
           positionY: 100,
           width: 100,

package/test/test/assets/chapters.vtt

@@ -3,8 +3,8 @@ WEBVTT
 00:00.000 --> 00:05.000
 Chapter 1
 
-00:05.000 --> 00:30.000
+00:05.000 --> 00:10.000
 Chapter 2
 
-00:30.000 --> 01:01.349
+00:10.000 --> 00:20.000
 Chapter 3

package/test/test/assets/chapters2.vtt

@@ -0,0 +1,10 @@
+WEBVTT
+
+00:20.000 --> 00:30.000
+Chapter 4
+
+00:30.000 --> 00:40.000
+Chapter 5
+
+00:40.000 --> 01:01.349
+Chapter 6

package/test/test/util/ttml_utils.js

@@ -0,0 +1,81 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.test.TtmlUtils');
+
+shaka.test.TtmlUtils = class {
+  /**
+   * @param {!Array} expectedCues
+   * @param {!Array} actualCues
+   * @param {!Object} bodyProperties
+   * @param {Object=} divProperties
+   */
+  static verifyHelper(expectedCues, actualCues, bodyProperties, divProperties) {
+    const mapExpected = (cue) => {
+      if (cue.region) {
+        cue.region = jasmine.objectContaining(cue.region);
+      }
+
+      if (cue.nestedCues && (cue.nestedCues instanceof Array)) {
+        cue.nestedCues = cue.nestedCues.map(mapExpected);
+      }
+
+      if (cue.isContainer == undefined) {
+        // If not specified to be true, check for isContainer to be false.
+        cue.isContainer = false;
+      }
+
+      return jasmine.objectContaining(cue);
+    };
+
+    /**
+     * @param {!Object} properties
+     * @return {!shaka.extern.Cue}
+     */
+    const makeContainer = (properties) => {
+      const region = {
+        id: '',
+        viewportAnchorX: 0,
+        viewportAnchorY: 0,
+        regionAnchorX: 0,
+        regionAnchorY: 0,
+        width: 100,
+        height: 100,
+        widthUnits: shaka.text.CueRegion.units.PERCENTAGE,
+        heightUnits: shaka.text.CueRegion.units.PERCENTAGE,
+        viewportAnchorUnits: shaka.text.CueRegion.units.PERCENTAGE,
+        scroll: '',
+      };
+      const containerCue = /** @type {!shaka.extern.Cue} */ ({
+        region,
+        nestedCues: jasmine.any(Object),
+        payload: '',
+        startTime: 0,
+        endTime: Infinity,
+        isContainer: true,
+      });
+      Object.assign(containerCue, properties);
+      return mapExpected(containerCue);
+    };
+
+    if (expectedCues.length == 0 && !divProperties) {
+      expect(actualCues.length).toBe(0);
+    } else {
+      // Body.
+      expect(actualCues.length).toBe(1);
+      const body = actualCues[0];
+      expect(body).toEqual(makeContainer(bodyProperties));
+
+      // Div.
+      expect(body.nestedCues.length).toBe(1);
+      const div = body.nestedCues[0];
+      expect(div).toEqual(makeContainer(divProperties || bodyProperties));
+
+      // Cues.
+      expect(div.nestedCues).toEqual(expectedCues.map(mapExpected));
+    }
+  }
+};

package/test/text/mp4_ttml_parser_unit.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+goog.require('shaka.test.TtmlUtils');
 goog.require('shaka.test.Util');
 goog.require('shaka.text.Mp4TtmlParser');
 goog.require('shaka.util.BufferUtils');
@@ -48,7 +49,14 @@ describe('Mp4TtmlParser', () => {
     parser.parseInit(ttmlInitSegment);
     const time = {periodStart: 0, segmentStart: 0, segmentEnd: 0};
     const ret = parser.parseMedia(ttmlSegmentMultipleMDAT, time);
-    expect(ret.length).toBe(20);
+    // Bodies.
+    expect(ret.length).toBe(2);
+    // Divs.
+    expect(ret[0].nestedCues.length).toBe(1);
+    expect(ret[1].nestedCues.length).toBe(1);
+    // Cues.
+    expect(ret[0].nestedCues[0].nestedCues.length).toBe(10);
+    expect(ret[1].nestedCues[0].nestedCues.length).toBe(10);
   });
 
   it('accounts for offset', () => {
@@ -159,22 +167,7 @@ describe('Mp4TtmlParser', () => {
     parser.parseInit(ttmlInitSegment);
     const time = {periodStart: 0, segmentStart: 0, segmentEnd: 0};
     const result = parser.parseMedia(ttmlSegment, time);
-    verifyHelper(cues, result);
+    shaka.test.TtmlUtils.verifyHelper(
+        cues, result, {startTime: 23, endTime: 53.5});
   });
-
-  function verifyHelper(/** !Array */ expected, /** !Array */ actual) {
-    const mapExpected = (cue) => {
-      if (cue.region) {
-        cue.region = jasmine.objectContaining(cue.region);
-      }
-
-      if (cue.nestedCues) {
-        cue.nestedCues = cue.nestedCues.map(mapExpected);
-      }
-
-      return jasmine.objectContaining(cue);
-    };
-
-    expect(actual).toEqual(expected.map(mapExpected));
-  }
 });