shaka-player 4.0.2 → 4.1.1

package/test/player_unit.js

@@ -6,6 +6,7 @@
 
 describe('Player', () => {
   const ContentType = shaka.util.ManifestParserUtils.ContentType;
+  const StreamUtils = shaka.util.StreamUtils;
   const Util = shaka.test.Util;
 
   const originalLogError = shaka.log.error;
@@ -29,6 +30,8 @@ describe('Player', () => {
   let player;
   /** @type {!shaka.test.FakeAbrManager} */
   let abrManager;
+  /** @type {function(!shaka.util.Error)} */
+  let onErrorCallback;
 
   /** @type {!shaka.test.FakeNetworkingEngine} */
   let networkingEngine;
@@ -40,6 +43,8 @@ describe('Player', () => {
   let playhead;
   /** @type {!shaka.test.FakeTextDisplayer} */
   let textDisplayer;
+  /** @type {shaka.extern.BufferedInfo} */
+  let bufferedInfo;
 
   let mediaSourceEngine;
 
@@ -101,6 +106,13 @@ describe('Player', () => {
     abrManager = new shaka.test.FakeAbrManager();
     textDisplayer = createTextDisplayer();
 
+    bufferedInfo = {
+      total: [],
+      audio: [],
+      video: [{start: 12, end: 26}],
+      text: [],
+    };
+
     function dependencyInjector(player) {
       // Create a networking engine that always returns an empty buffer.
       networkingEngine = new shaka.test.FakeNetworkingEngine();
@@ -119,10 +131,14 @@ describe('Player', () => {
         setSegmentRelativeVttTiming:
             jasmine.createSpy('setSegmentRelativeVttTiming'),
         getTextDisplayer: () => textDisplayer,
+        getBufferedInfo: () => bufferedInfo,
         ended: jasmine.createSpy('ended').and.returnValue(false),
       };
 
-      player.createDrmEngine = () => drmEngine;
+      player.createDrmEngine = ({onError}) => {
+        onErrorCallback = onError;
+        return drmEngine;
+      };
       player.createNetworkingEngine = () => networkingEngine;
       player.createPlayhead = (startTime) => {
         const callableSetStartTime =
@@ -321,6 +337,131 @@ describe('Player', () => {
       });
     });
 
+    describe('onError and tryToRecoverFromError', () => {
+      const httpError = new shaka.util.Error(
+          shaka.util.Error.Severity.RECOVERABLE,
+          shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.HTTP_ERROR);
+      const nonHttpError = new shaka.util.Error(
+          shaka.util.Error.Severity.RECOVERABLE,
+          shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.TIMEOUT);
+      /** @type {?jasmine.Spy} */
+      let dispatchEventSpy;
+
+      beforeEach(async () => {
+        manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+          manifest.addVariant(11, (variant) => {
+            variant.addAudio(2);
+            variant.addVideo(3);
+          });
+          manifest.addVariant(12, (variant) => {
+            variant.addAudio(4);
+            variant.addVideo(5);
+          });
+        });
+        await player.load(fakeManifestUri, 0, fakeMimeType);
+        dispatchEventSpy = spyOn(player, 'dispatchEvent').and.returnValue(true);
+      });
+
+      afterEach(() => {
+        dispatchEventSpy.calls.reset();
+      });
+
+      it('does not handle non NETWORK HTTP_ERROR', () => {
+        onErrorCallback(nonHttpError);
+        expect(nonHttpError.handled).toBeFalsy();
+        expect(player.dispatchEvent).toHaveBeenCalled();
+      });
+
+      describe('when config.streaming.maxDisabledTime is 0', () => {
+        it('does not handle NETWORK HTTP_ERROR', () => {
+          player.configure({streaming: {maxDisabledTime: 0}});
+          httpError.handled = false;
+          onErrorCallback(httpError);
+          expect(httpError.handled).toBeFalsy();
+          expect(player.dispatchEvent).toHaveBeenCalled();
+        });
+      });
+
+      describe('when config.streaming.maxDisabledTime is 30', () => {
+        /** @type {number} */
+        const maxDisabledTime = 30;
+        /** @type {number} */
+        const currentTime = 123;
+        const chosenVariant = {
+          id: 1,
+          language: 'es',
+          disabledUntilTime: 0,
+          primary: false,
+          bandwidth: 2100,
+          allowedByApplication: true,
+          allowedByKeySystem: true,
+          decodingInfos: [],
+        };
+        /** @type {?jasmine.Spy} */
+        let applyRestrictionsSpy;
+        /** @type {?jasmine.Spy} */
+        let chooseVariantSpy;
+        /** @type {?jasmine.Spy} */
+        let getBufferedInfoSpy;
+        /** @type {?jasmine.Spy} */
+        let switchVariantSpy;
+
+        describe('and there is new variant', () => {
+          const oldDateNow = Date.now;
+          beforeEach(() => {
+            Date.now = () => currentTime * 1000;
+            chooseVariantSpy = spyOn(player, 'chooseVariant_')
+                .and.returnValue(chosenVariant);
+            getBufferedInfoSpy = spyOn(player, 'getBufferedInfo')
+                .and.returnValue(bufferedInfo);
+            switchVariantSpy = spyOn(player, 'switchVariant_');
+            applyRestrictionsSpy = spyOn(StreamUtils, 'applyRestrictions');
+            httpError.handled = false;
+            dispatchEventSpy.calls.reset();
+            player.configure({streaming: {maxDisabledTime}});
+            player.setMaxHardwareResolution(123, 456);
+            onErrorCallback(httpError);
+          });
+
+          afterEach(() => {
+            Date.now = oldDateNow;
+            chooseVariantSpy.calls.reset();
+            getBufferedInfoSpy.calls.reset();
+            switchVariantSpy.calls.reset();
+            applyRestrictionsSpy.calls.reset();
+          });
+
+          it('handles HTTP_ERROR', () => {
+            expect(httpError.handled).toBeTruthy();
+          });
+
+          it('does not dispatch any error', () => {
+            expect(dispatchEventSpy).not.toHaveBeenCalled();
+          });
+
+          it('disables the current variant and applies restrictions', () => {
+            const foundDisabledVariant =
+                manifest.variants.some(({disabledUntilTime}) =>
+                  disabledUntilTime == currentTime + maxDisabledTime);
+            expect(foundDisabledVariant).toBeTruthy();
+            expect(applyRestrictionsSpy).toHaveBeenCalledWith(
+                manifest.variants,
+                player.getConfiguration().restrictions,
+                {width: 123, height: 456});
+          });
+
+          it('switches the variant', () => {
+            expect(chooseVariantSpy).toHaveBeenCalled();
+            expect(getBufferedInfoSpy).toHaveBeenCalled();
+            expect(switchVariantSpy)
+                .toHaveBeenCalledWith(chosenVariant, false, true, 14);
+          });
+        });
+      });
+    });
+
     describe('setTextTrackVisibility', () => {
       beforeEach(() => {
         manifest = shaka.test.ManifestGenerator.generate((manifest) => {

package/test/test/util/manifest_generator.js

@@ -265,6 +265,8 @@ shaka.test.ManifestGenerator.Variant = class {
       this.language = 'und';
       /** @type {number} */
       this.bandwidth = 0;
+      /** @type {number} */
+      this.disabledUntilTime = 0;
       /** @type {boolean} */
       this.primary = false;
       /** @type {boolean} */

package/test/test/util/simple_fakes.js

@@ -333,6 +333,12 @@ shaka.test.FakePlayhead = class {
     /** @private {number} */
     this.startTime_ = 0;
 
+    /** @private {number} */
+    this.gapsJumped_ = 0;
+
+    /** @private {number} */
+    this.stallsDetected_ = 0;
+
     /** @type {!jasmine.Spy} */
     this.setStartTime = jasmine.createSpy('setStartTime')
         .and.callFake((value) => {
@@ -343,6 +349,14 @@ shaka.test.FakePlayhead = class {
     this.getTime = jasmine.createSpy('getTime')
         .and.callFake(() => this.startTime_);
 
+    /** @type {!jasmine.Spy} */
+    this.getGapsJumped = jasmine.createSpy('getGapsJumped')
+        .and.callFake(() => this.gapsJumped_);
+
+    /** @type {!jasmine.Spy} */
+    this.getStallsDetected = jasmine.createSpy('getTime')
+        .and.callFake(() => this.stallsDetected_);
+
     /** @type {!jasmine.Spy} */
     this.setBuffering = jasmine.createSpy('setBuffering');
 

package/test/test/util/streaming_engine_util.js

@@ -287,6 +287,7 @@ shaka.test.StreamingEngineUtil = class {
       bandwidth: 0,
       id: 0,
       language: 'und',
+      disabledUntilTime: 0,
       primary: false,
       decodingInfos: [],
     };

package/test/text/vtt_text_parser_unit.js

@@ -624,6 +624,7 @@ describe('VttTextParser', () => {
   });
 
   it('supports global style blocks', () => {
+    const textShadow = '-1px 0 black, 0 1px black, 1px 0 black, 0 -1px black';
     verifyHelper(
         [
           {
@@ -632,6 +633,7 @@ describe('VttTextParser', () => {
             payload: 'Test',
             color: 'cyan',
             fontSize: '10px',
+            textShadow: textShadow,
           },
           {
             startTime: 40,
@@ -639,6 +641,7 @@ describe('VttTextParser', () => {
             payload: 'Test2',
             color: 'cyan',
             fontSize: '10px',
+            textShadow: textShadow,
           },
         ],
         'WEBVTT\n\n' +
@@ -646,6 +649,7 @@ describe('VttTextParser', () => {
         '::cue {\n' +
         'color: cyan;\n'+
         'font-size: 10px;\n'+
+        `text-shadow: ${textShadow};\n`+
         '}\n\n' +
         '00:00:20.000 --> 00:00:40.000\n' +
         'Test\n\n' +

package/test/ui/ui_unit.js

@@ -809,12 +809,25 @@ describe('UI', () => {
         }
       });
       it('is updated periodically', async () => {
-        function getStatsFromContainer() {
+        // There is no guaranteed ordering, so fetch by the stat name.
+        function getStatsElementByName(name) {
           const nodes = statisticsContainer.childNodes;
-          width = nodes[0].childNodes[1].textContent.replace(' (px)', '');
-          height = nodes[1].childNodes[1].textContent.replace(' (px)', '');
-          bufferingTime =
-              nodes[13].childNodes[1].textContent.replace(' (s)', '');
+          for (const node of nodes) {
+            if (node.hasChildNodes() &&
+                node.childNodes[0].textContent.includes(name)) {
+              return node;
+            }
+          }
+          return null;
+        }
+
+        function getStatsFromContainer() {
+          width = getStatsElementByName(
+              'width').childNodes[1].textContent.replace(' (px)', '');
+          height = getStatsElementByName(
+              'height').childNodes[1].textContent.replace(' (px)', '');
+          bufferingTime = getStatsElementByName(
+              'bufferingTime').childNodes[1].textContent.replace(' (s)', '');
         }
 
         /** @type {!string} */

package/test/util/stream_utils_unit.js

@@ -902,4 +902,112 @@ describe('StreamUtils', () => {
       expect(manifest.variants[0].video.id).toBe(2);
     });
   });
+
+  describe('meetsRestrictions', () => {
+    const oldDateNow = Date.now;
+    /* @param {shaka.extern.Restrictions} */
+    const restrictions = {
+      minWidth: 10,
+      maxWidth: 20,
+      minHeight: 10,
+      maxHeight: 20,
+      minPixels: 10,
+      maxPixels: 20,
+      minFrameRate: 21,
+      maxFrameRate: 25,
+      minBandwidth: 1000,
+      maxBandwidth: 3000,
+    };
+    /* @param {{width: number, height: number}} */
+    const maxHwRes = {width: 123, height: 456};
+    /* @param {shaka.extern.Variant} */
+    let variant;
+    /* @param {boolean} */
+    let meetsRestrictionsResult;
+
+    beforeEach(() => {
+      Date.now = () => 123 * 1000;
+    });
+
+    afterEach(() => {
+      Date.now = oldDateNow;
+    });
+
+    /*
+     * @param {number} disabledUntilTime
+     */
+    const checkRestrictions = ({disabledUntilTime = 0}) => {
+      /* @param {shaka.extern.Variant} */
+      variant = {
+        id: 1,
+        language: 'es',
+        disabledUntilTime,
+        video: null,
+        audio: null,
+        primary: false,
+        bandwidth: 2000,
+        allowedByApplication: true,
+        allowedByKeySystem: true,
+        decodingInfos: [],
+      };
+      meetsRestrictionsResult = StreamUtils.meetsRestrictions(variant,
+          restrictions, maxHwRes);
+    };
+
+    describe('when disabledUntilTime > now', () => {
+      beforeEach(() => {
+        checkRestrictions({disabledUntilTime: 124});
+      });
+
+      it('does not meet the restrictions', () => {
+        expect(meetsRestrictionsResult).toBeFalsy();
+      });
+
+      it('does not reset disabledUntilTime', () => {
+        expect(variant.disabledUntilTime).toBe(124);
+      });
+    });
+
+    describe('when disabledUntilTime == now', () => {
+      beforeEach(() => {
+        checkRestrictions({disabledUntilTime: 123});
+      });
+
+      it('meets the restrictions', () => {
+        expect(meetsRestrictionsResult).toBeTruthy();
+      });
+
+      it('resets disabledUntilTime', () => {
+        expect(variant.disabledUntilTime).toBe(0);
+      });
+    });
+
+    describe('when disabledUntilTime == now', () => {
+      beforeEach(() => {
+        checkRestrictions({disabledUntilTime: 122});
+      });
+
+      it('meets the restrictions', () => {
+        expect(meetsRestrictionsResult).toBeTruthy();
+      });
+
+      it('resets disabledUntilTime', () => {
+        expect(variant.disabledUntilTime).toBe(0);
+      });
+    });
+
+    describe('when disabledUntilTime == 0', () => {
+      beforeEach(() => {
+        checkRestrictions({disabledUntilTime: 0});
+      });
+
+      it('meets the restrictions', () => {
+        expect(meetsRestrictionsResult).toBeTruthy();
+      });
+
+      it('leaves disabledUntilTime = 0', () => {
+        expect(variant.disabledUntilTime).toBe(0);
+      });
+    });
+  });
 });

package/ui/controls.js

@@ -53,7 +53,8 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
 
     /** @private {shaka.cast.CastProxy} */
     this.castProxy_ = new shaka.cast.CastProxy(
-        video, player, this.config_.castReceiverAppId);
+        video, player, this.config_.castReceiverAppId,
+        this.config_.castAndroidReceiverCompatible);
 
     /** @private {boolean} */
     this.castAllowed_ = true;
@@ -315,7 +316,8 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
   configure(config) {
     this.config_ = config;
 
-    this.castProxy_.changeReceiverId(config.castReceiverAppId);
+    this.castProxy_.changeReceiverId(config.castReceiverAppId,
+        config.castAndroidReceiverCompatible);
 
     // Deconstruct the old layout if applicable
     if (this.seekBar_) {
@@ -1258,21 +1260,23 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
       return;
     }
 
+    const keyboardSeekDistance = this.config_.keyboardSeekDistance;
+
     switch (event.key) {
       case 'ArrowLeft':
         // If it's not focused on the volume bar, move the seek time backward
-        // for 5 sec. Otherwise, the volume will be adjusted automatically.
-        if (this.seekBar_ && !isVolumeBar) {
+        // for a few sec. Otherwise, the volume will be adjusted automatically.
+        if (this.seekBar_ && !isVolumeBar && keyboardSeekDistance > 0) {
           event.preventDefault();
-          this.seek_(this.seekBar_.getValue() - 5);
+          this.seek_(this.seekBar_.getValue() - keyboardSeekDistance);
         }
         break;
       case 'ArrowRight':
         // If it's not focused on the volume bar, move the seek time forward
-        // for 5 sec. Otherwise, the volume will be adjusted automatically.
-        if (this.seekBar_ && !isVolumeBar) {
+        // for a few sec. Otherwise, the volume will be adjusted automatically.
+        if (this.seekBar_ && !isVolumeBar && keyboardSeekDistance > 0) {
           event.preventDefault();
-          this.seek_(this.seekBar_.getValue() + 5);
+          this.seek_(this.seekBar_.getValue() + keyboardSeekDistance);
         }
         break;
       // Jump to the beginning of the video's seek range.

package/ui/externs/ui.js

@@ -72,6 +72,7 @@ shaka.extern.UIVolumeBarColors;
  *   addBigPlayButton: boolean,
  *   customContextMenu: boolean,
  *   castReceiverAppId: string,
+ *   castAndroidReceiverCompatible: boolean,
  *   clearBufferOnQualityChange: boolean,
  *   showUnbufferedStart: boolean,
  *   seekBarColors: shaka.extern.UISeekBarColors,
@@ -83,7 +84,8 @@ shaka.extern.UIVolumeBarColors;
  *   enableKeyboardPlaybackControls: boolean,
  *   enableFullscreenOnRotation: boolean,
  *   forceLandscapeOnFullscreen: boolean,
- *   enableTooltips: boolean
+ *   enableTooltips: boolean,
+ *   keyboardSeekDistance: number
  * }}
  *
  * @property {!Array.<string>} controlPanelElements
@@ -109,6 +111,8 @@ shaka.extern.UIVolumeBarColors;
  *   Whether or not a custom context menu replaces the default.
  * @property {string} castReceiverAppId
  *   Receiver app id to use for the Chromecast support.
+ * @property {boolean} castAndroidReceiverCompatible
+ *   Indicates if the app is compatible with an Android Cast Receiver.
  * @property {boolean} clearBufferOnQualityChange
  *   Only applicable if the resolution selection is part of the UI.
  *   Whether buffer should be cleared when changing resolution
@@ -174,6 +178,11 @@ shaka.extern.UIVolumeBarColors;
  *   Whether or not buttons in the control panel display tooltips that contain
  *   information about their function.
  *   Defaults to false.
+ * @property {number} keyboardSeekDistance
+ *   The time interval, in seconds, to seek when the user presses the left or
+ *   right keyboard keys when the video is selected. If less than or equal to 0,
+ *   no seeking will occur.
+ *   Defaults to 5 seconds.
  * @exportDoc
  */
 shaka.extern.UIConfiguration;

package/ui/statistics_button.js

@@ -109,6 +109,14 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
           this.currentStats_[name], false) + ' (m)';
     };
 
+    const parseGaps = (name) => {
+      return this.currentStats_[name] + ' (gaps)';
+    };
+
+    const parseStalls = (name) => {
+      return this.currentStats_[name] + ' (stalls)';
+    };
+
     /** @private {!Object.<string, function(string):string>} */
     this.parseFrom_ = {
       'width': parsePx,
@@ -128,6 +136,8 @@ shaka.ui.StatisticsButton = class extends shaka.ui.Element {
       'corruptedFrames': parseFrames,
       'decodedFrames': parseFrames,
       'droppedFrames': parseFrames,
+      'stallsDetected': parseStalls,
+      'gapsJumped': parseGaps,
     };
 
     /** @private {shaka.util.Timer} */

package/ui/ui.js

@@ -218,6 +218,7 @@ shaka.ui.Overlay = class {
       addBigPlayButton: false,
       customContextMenu: false,
       castReceiverAppId: '',
+      castAndroidReceiverCompatible: false,
       clearBufferOnQualityChange: true,
       showUnbufferedStart: false,
       seekBarColors: {
@@ -238,6 +239,7 @@ shaka.ui.Overlay = class {
       enableFullscreenOnRotation: true,
       forceLandscapeOnFullscreen: true,
       enableTooltips: false,
+      keyboardSeekDistance: 5,
     };
 
     // Check AirPlay support
@@ -388,19 +390,28 @@ shaka.ui.Overlay = class {
     // Get and configure cast app id.
     let castAppId = '';
 
+    // Get and configure cast Android Receiver Compatibility
+    let castAndroidReceiverCompatible = false;
+
     // Cast receiver id can be specified on either container or video.
     // It should not be provided on both. If it was, we will use the last
     // one we saw.
     if (container['dataset'] &&
         container['dataset']['shakaPlayerCastReceiverId']) {
       castAppId = container['dataset']['shakaPlayerCastReceiverId'];
+      castAndroidReceiverCompatible =
+          container['dataset']['shakaPlayerCastAndroidReceiverCompatible'] ===
+          'true';
     } else if (video['dataset'] &&
                video['dataset']['shakaPlayerCastReceiverId']) {
       castAppId = video['dataset']['shakaPlayerCastReceiverId'];
+      castAndroidReceiverCompatible =
+        video['dataset']['shakaPlayerCastAndroidReceiverCompatible'] === 'true';
     }
 
     if (castAppId.length) {
-      ui.configure({castReceiverAppId: castAppId});
+      ui.configure({castReceiverAppId: castAppId,
+        castAndroidReceiverCompatible: castAndroidReceiverCompatible});
     }
 
     if (shaka.util.Dom.asHTMLMediaElement(video).controls) {