shaka-player 4.2.3 → 4.2.5

package/test/media/streaming_engine_unit.js

@@ -878,7 +878,7 @@ describe('StreamingEngine', () => {
 
     const config = shaka.util.PlayerConfiguration.createDefault().streaming;
     config.bufferingGoal = 60;
-    config.failureCallback = () => streamingEngine.retry();
+    config.failureCallback = () => streamingEngine.retry(0.1);
     createStreamingEngine(config);
 
     // Make requests for different types take different amounts of time.
@@ -1737,8 +1737,23 @@ describe('StreamingEngine', () => {
     beforeEach(() => {
       setupLive();
       mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData, 0);
-      createStreamingEngine();
+
+      // Retry on failure for live streams.
+      const config = shaka.util.PlayerConfiguration.createDefault().streaming;
+      config.failureCallback = () => streamingEngine.retry(0.1);
+
+      createStreamingEngine(config);
       presentationTimeInSeconds = 100;
+
+      // Ignore 404 errors in live stream tests.
+      onError.and.callFake((error) => {
+        if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS &&
+            error.data[1] == 404) {
+          // 404 error
+        } else {
+          fail(error);
+        }
+      });
     });
 
     it('outside segment availability window', async () => {
@@ -1768,24 +1783,22 @@ describe('StreamingEngine', () => {
       const originalAppendBuffer =
           // eslint-disable-next-line no-restricted-syntax
           shaka.test.FakeMediaSourceEngine.prototype.appendBufferImpl;
-      mediaSourceEngine.appendBuffer.and.callFake(
-          (type, data, reference) => {
-            expect(presentationTimeInSeconds).toBe(125);
-            if (reference && reference.startTime >= 100) {
-              // Ignore a possible call for the first Period.
-              expect(Util.invokeSpy(timeline.getSegmentAvailabilityStart))
-                  .toBe(100);
-              expect(Util.invokeSpy(timeline.getSegmentAvailabilityEnd))
-                  .toBe(120);
-              playing = true;
-              mediaSourceEngine.appendBuffer.and.callFake(
-                  originalAppendBuffer);
-            }
+      mediaSourceEngine.appendBuffer.and.callFake((type, data, reference) => {
+        expect(presentationTimeInSeconds).toBe(125);
+        // Ignore a possible call for the first Period.
+        if (reference && reference.startTime >= 100) {
+          expect(Util.invokeSpy(timeline.getSegmentAvailabilityStart))
+              .not.toBeLessThan(100);
+          expect(Util.invokeSpy(timeline.getSegmentAvailabilityEnd))
+              .not.toBeLessThan(120);
+          playing = true;
+          mediaSourceEngine.appendBuffer.and.callFake(originalAppendBuffer);
+        }
 
-            // eslint-disable-next-line no-restricted-syntax
-            return originalAppendBuffer.call(
-                mediaSourceEngine, type, data, reference);
-          });
+        // eslint-disable-next-line no-restricted-syntax
+        return originalAppendBuffer.call(
+            mediaSourceEngine, type, data, reference);
+      });
 
       await runTest(slideSegmentAvailabilityWindow);
       // Verify buffers.
@@ -2001,7 +2014,7 @@ describe('StreamingEngine', () => {
       mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
 
       const config = shaka.util.PlayerConfiguration.createDefault().streaming;
-      config.failureCallback = () => streamingEngine.retry();
+      config.failureCallback = () => streamingEngine.retry(0.1);
       createStreamingEngine(config);
 
       presentationTimeInSeconds = 100;
@@ -2162,7 +2175,7 @@ describe('StreamingEngine', () => {
         netEngine.request.calls.reset();
 
         // Retry streaming.
-        expect(streamingEngine.retry()).toBe(true);
+        expect(streamingEngine.retry(0.1)).toBe(true);
       });
 
       // Here we go!
@@ -2192,7 +2205,7 @@ describe('StreamingEngine', () => {
 
         // Retry streaming, which should fail and return false.
         netEngine.request.calls.reset();
-        expect(streamingEngine.retry()).toBe(false);
+        expect(streamingEngine.retry(0.1)).toBe(false);
       });
 
       // Here we go!
@@ -2244,7 +2257,7 @@ describe('StreamingEngine', () => {
 
           // Retry streaming, which should fail and return false.
           netEngine.request.calls.reset();
-          expect(streamingEngine.retry()).toBe(false);
+          expect(streamingEngine.retry(0.1)).toBe(false);
         }
       });
 

package/test/player_unit.js

@@ -3940,6 +3940,93 @@ describe('Player', () => {
     });
   });
 
+  describe('config streaming.failureCallback default', () => {
+    /** @type {jasmine.Spy} */
+    let retryStreaming;
+    /** @type {jasmine.Spy} */
+    let isLive;
+
+    /**
+     * @suppress {accessControls}
+     * @param {!shaka.util.Error} error
+     */
+    function defaultStreamingFailureCallback(error) {
+      player.defaultStreamingFailureCallback_(error);
+    }
+
+    beforeEach(() => {
+      retryStreaming = jasmine.createSpy('retryStreaming');
+      isLive = jasmine.createSpy('isLive');
+
+      player.retryStreaming = Util.spyFunc(retryStreaming);
+      player.isLive = Util.spyFunc(isLive);
+    });
+
+    it('ignores VOD failures', () => {
+      isLive.and.returnValue(false);
+
+      const error = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.BAD_HTTP_STATUS,
+          /* url= */ '',
+          /* http_status= */ 404);
+
+      defaultStreamingFailureCallback(error);
+      expect(retryStreaming).not.toHaveBeenCalled();
+    });
+
+    it('retries live on HTTP 404', () => {
+      isLive.and.returnValue(true);
+
+      const error = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.BAD_HTTP_STATUS,
+          /* url= */ '',
+          /* http_status= */ 404);
+
+      defaultStreamingFailureCallback(error);
+      expect(retryStreaming).toHaveBeenCalled();
+    });
+
+    it('retries live on generic HTTP error', () => {
+      isLive.and.returnValue(true);
+
+      const error = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.HTTP_ERROR);
+
+      defaultStreamingFailureCallback(error);
+      expect(retryStreaming).toHaveBeenCalled();
+    });
+
+    it('retries live on HTTP timeout', () => {
+      isLive.and.returnValue(true);
+
+      const error = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.TIMEOUT);
+
+      defaultStreamingFailureCallback(error);
+      expect(retryStreaming).toHaveBeenCalled();
+    });
+
+    it('ignores other live failures', () => {
+      isLive.and.returnValue(true);
+
+      const error = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.VIDEO_ERROR);
+
+      defaultStreamingFailureCallback(error);
+      expect(retryStreaming).not.toHaveBeenCalled();
+    });
+  });
+
   /**
    * Gets the currently active variant track.
    * @return {shaka.extern.Track}

package/test/polyfill/media_capabilities_unit.js

@@ -0,0 +1,261 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('MediaCapabilities', () => {
+  const Util = shaka.test.Util;
+  const originalCast = window['cast'];
+  const originalVendor = navigator.vendor;
+  const originalUserAgent = navigator.userAgent;
+  const originalRequestMediaKeySystemAccess =
+    navigator.requestMediaKeySystemAccess;
+  const originalMediaCapabilities = navigator.mediaCapabilities;
+
+  /** @type {MediaDecodingConfiguration} */
+  let mockDecodingConfig;
+  /** @type {!jasmine.Spy} */
+  let mockCanDisplayType;
+
+  beforeAll(() => {
+    Object.defineProperty(window['navigator'],
+        'userAgent', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'vendor', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'requestMediaKeySystemAccess', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'mediaCapabilities', {
+          value: undefined, configurable: true,
+          writable: true,
+        });
+  });
+
+  beforeEach(() => {
+    mockDecodingConfig = {
+      audio: {
+        bitrate: 100891,
+        channels: 2,
+        contentType: 'audio/mp4; codecs="mp4a.40.2"',
+        samplerate: 48000,
+        spatialRendering: false,
+      },
+      keySystemConfiguration: {
+        audio: {robustness: 'SW_SECURE_CRYPTO'},
+        distinctiveIdentifier: 'optional',
+        initDataType: 'cenc',
+        keySystem: 'com.widevine.alpha',
+        persistentState: 'optional',
+        sessionTypes: ['temporary'],
+        video: {robustness: 'SW_SECURE_CRYPTO'},
+      },
+      type: 'media-source',
+      video: {
+        bitrate: 349265,
+        contentType: 'video/mp4; codecs="avc1.4D4015"',
+        framerate: 23.976023976023978,
+        height: 288,
+        width: 512,
+      },
+    };
+    shaka.polyfill.MediaCapabilities.memoizedMediaKeySystemAccessRequests_ = {};
+
+    mockCanDisplayType = jasmine.createSpy('canDisplayType');
+    mockCanDisplayType.and.returnValue(false);
+  });
+
+  afterEach(() => {
+    window['cast'] = originalCast;
+  });
+
+  afterAll(() => {
+    window['cast'] = originalCast;
+    Object.defineProperty(window['navigator'],
+        'userAgent', {value: originalUserAgent});
+    Object.defineProperty(window['navigator'],
+        'vendor', {value: originalVendor});
+    Object.defineProperty(window['navigator'],
+        'requestMediaKeySystemAccess',
+        {value: originalRequestMediaKeySystemAccess});
+    Object.defineProperty(window['navigator'],
+        'mediaCapabilities', {value: originalMediaCapabilities});
+  });
+
+  describe('install', () => {
+    it('should define decoding info method', () => {
+      shaka.polyfill.MediaCapabilities.install();
+
+      expect(navigator.mediaCapabilities.decodingInfo).toBeDefined();
+    });
+  });
+
+  describe('decodingInfo', () => {
+    it('should check codec support when MediaDecodingConfiguration.type ' +
+      'is "media-source"', () => {
+      const isTypeSupportedSpy =
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+      shaka.polyfill.MediaCapabilities.install();
+      navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      expect(isTypeSupportedSpy).toHaveBeenCalledTimes(2);
+      expect(isTypeSupportedSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.video.contentType,
+      );
+      expect(isTypeSupportedSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.audio.contentType,
+      );
+    });
+
+    it('should check codec support when MediaDecodingConfiguration.type ' +
+      'is "file"', () => {
+      const supportsMediaTypeSpy =
+          spyOn(shaka['util']['Platform'],
+              'supportsMediaType').and.returnValue(true);
+      mockDecodingConfig.type = 'file';
+      shaka.polyfill.MediaCapabilities.install();
+      navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      expect(supportsMediaTypeSpy).toHaveBeenCalledTimes(2);
+      expect(supportsMediaTypeSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.video.contentType,
+      );
+      expect(supportsMediaTypeSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.audio.contentType,
+      );
+    });
+
+    it('should check MediaKeySystem when keySystemConfiguration is present',
+        async () => {
+          const mockResult = {mockKeySystemAccess: 'mockKeySystemAccess'};
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+          const requestKeySystemAccessSpy =
+          spyOn(window['navigator'],
+              'requestMediaKeySystemAccess').and.returnValue(mockResult);
+
+          shaka.polyfill.MediaCapabilities.install();
+          const result = await navigator.mediaCapabilities
+              .decodingInfo(mockDecodingConfig);
+
+          expect(requestKeySystemAccessSpy).toHaveBeenCalledWith(
+              'com.widevine.alpha',
+              [{
+                audioCapabilities: [
+                  {
+                    robustness: 'SW_SECURE_CRYPTO',
+                    contentType: 'audio/mp4; codecs="mp4a.40.2"',
+                  },
+                ],
+                distinctiveIdentifier: 'optional',
+                initDataTypes: ['cenc'],
+                persistentState: 'optional',
+                sessionTypes: ['temporary'],
+                videoCapabilities: [{
+                  robustness: 'SW_SECURE_CRYPTO',
+                  contentType: 'video/mp4; codecs="avc1.4D4015"',
+                }],
+              }],
+          );
+          expect(result.keySystemAccess).toEqual(mockResult);
+        });
+
+    it('throws when the cast namespace is not available', async () => {
+      // Temporarily remove window.cast to trigger error. It's restored after
+      // every test.
+      delete window['cast'];
+
+      const isChromecastSpy =
+          spyOn(shaka['util']['Platform'],
+              'isChromecast').and.returnValue(true);
+      const expected = Util.jasmineError(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.CAST,
+          shaka.util.Error.Code.CAST_API_UNAVAILABLE));
+      const isTypeSupportedSpy =
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+
+      shaka.polyfill.MediaCapabilities.install();
+      await expectAsync(
+          navigator.mediaCapabilities.decodingInfo(mockDecodingConfig))
+          .toBeRejectedWith(expected);
+
+      expect(isTypeSupportedSpy).not.toHaveBeenCalled();
+      // 1 (during install()) + 1 (for video config check).
+      expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('falls back to isTypeSupported() when canDisplayType() missing',
+        async () => {
+          // We only set the cast namespace, but not the canDisplayType() API.
+          window['cast'] = {};
+          const isChromecastSpy =
+              spyOn(shaka['util']['Platform'],
+                  'isChromecast').and.returnValue(true);
+          const isTypeSupportedSpy =
+              spyOn(window['MediaSource'], 'isTypeSupported')
+                  .and.returnValue(true);
+
+          shaka.polyfill.MediaCapabilities.install();
+          await navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+          expect(mockCanDisplayType).not.toHaveBeenCalled();
+          // 1 (during install()) + 1 (for video config check).
+          expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+          // 1 (fallback in canCastDisplayType()) +
+          // 1 (mockDecodingConfig.audio).
+          expect(isTypeSupportedSpy).toHaveBeenCalledTimes(2);
+        });
+
+    it('should use cast.__platform__.canDisplayType for "supported" field ' +
+        'when platform is Cast', async () => {
+      // We're using quotes to access window.cast because the compiler
+      // knows about lots of Cast-specific APIs we aren't mocking.  We
+      // don't need this mock strictly type-checked.
+      window['cast'] = {
+        __platform__: {canDisplayType: mockCanDisplayType},
+      };
+      const isChromecastSpy =
+          spyOn(shaka['util']['Platform'],
+              'isChromecast').and.returnValue(true);
+      const isTypeSupportedSpy =
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+
+      // Tests an HDR stream's extended MIME type is correctly provided.
+      mockDecodingConfig.video.transferFunction = 'pq';
+      mockDecodingConfig.video.contentType =
+          'video/mp4; codecs="hev1.2.4.L153.B0"';
+      // Round to a whole number since we can't rely on number => string
+      // conversion precision on all devices.
+      mockDecodingConfig.video.framerate = 24;
+      mockCanDisplayType.and.callFake((type) => {
+        expect(type).toBe(
+            'video/mp4; ' +
+            'codecs="hev1.2.4.L153.B0"; ' +
+            'width=512; ' +
+            'height=288; ' +
+            'framerate=24; ' +
+            'eotf=smpte2084');
+        return true;
+      });
+
+      shaka.polyfill.MediaCapabilities.install();
+      await navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      // 1 (during install()) + 1 (for video config check).
+      expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+      // 1 (mockDecodingConfig.audio).
+      expect(isTypeSupportedSpy).toHaveBeenCalledTimes(1);
+      // Called once in canCastDisplayType.
+      expect(mockCanDisplayType).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/test/test/util/simple_fakes.js

@@ -339,6 +339,9 @@ shaka.test.FakePlayhead = class {
     /** @private {number} */
     this.stallsDetected_ = 0;
 
+    /** @type {!jasmine.Spy} */
+    this.ready = jasmine.createSpy('ready');
+
     /** @type {!jasmine.Spy} */
     this.setStartTime = jasmine.createSpy('setStartTime')
         .and.callFake((value) => {