shaka-player 3.1.4 → 3.3.0

package/test/media/quality_observer_unit.js

@@ -0,0 +1,139 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.require('shaka.media.QualityObserver');
+goog.require('shaka.test.Util');
+
+
+describe('QualityObserver', () => {
+  /** @type {!shaka.media.QualityObserver} */
+  let observer;
+
+  /** @type {!jasmine.Spy} */
+  let onQualityChange;
+
+  const createQualityInfo = (contentType, bandwidth) => {
+    return {
+      bandwidth: bandwidth,
+      audioSamplingRate: 444000,
+      codecs: 'my codec',
+      contentType: contentType,
+      frameRate: 30,
+      height: 720,
+      mimeType: 'mime type',
+      channelsCount: 2,
+      pixelAspectRatio: '1:1',
+      width: 1280,
+    };
+  };
+  let emptyBuffer = true;
+  let bufferStart = 0;
+  let bufferEnd = 0;
+
+  const quality1 = createQualityInfo('video', 1);
+  const quality2 = createQualityInfo('video', 2);
+
+  const getBufferedInfo = () => {
+    if (emptyBuffer) {
+      return {
+        video: [],
+      };
+    }
+    return {
+      video: [{start: bufferStart, end: bufferEnd}],
+    };
+  };
+
+  beforeEach(() => {
+    onQualityChange = jasmine.createSpy('onQualityChange');
+    observer = new shaka.media.QualityObserver(getBufferedInfo);
+    observer.setListeners(shaka.test.Util.spyFunc(onQualityChange));
+    emptyBuffer = true;
+    bufferStart = 0;
+    bufferEnd = 0;
+  });
+
+  it('does not call onQualityChange when there are no quality changes', () => {
+    observer.poll(10, false);
+    expect(onQualityChange).not.toHaveBeenCalled();
+  });
+
+  it('calls onQualityChange when position is after 1st quality change', () => {
+    observer.addMediaQualityChange(quality1, 10);
+    emptyBuffer = false;
+    bufferStart = 10;
+    bufferEnd = 20;
+    observer.poll(10, false);
+    expect(onQualityChange).toHaveBeenCalledWith(quality1, 10);
+  });
+
+  it('does not call onQualityChange when pos advances with no change', () => {
+    observer.addMediaQualityChange(quality1, 10);
+    emptyBuffer = false;
+    bufferStart = 10;
+    bufferEnd = 20;
+    observer.poll(10, false);
+    expect(onQualityChange).toHaveBeenCalledWith(quality1, 10);
+    observer.poll(11, false);
+    expect(onQualityChange).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not call onQualityChange on seek to unbuffered position', () => {
+    observer.addMediaQualityChange(quality1, 10);
+    emptyBuffer = false;
+    bufferStart = 10;
+    bufferEnd = 20;
+    observer.poll(15, false);
+    expect(onQualityChange).toHaveBeenCalledOnceMoreWith([quality1, 15]);
+    observer.addMediaQualityChange(quality2, 20);
+    observer.poll(25, true);
+    expect(onQualityChange).not.toHaveBeenCalledOnceMore();
+    bufferEnd = 30;
+    observer.poll(26, false);
+    expect(onQualityChange).toHaveBeenCalledOnceMoreWith([quality2, 26]);
+  });
+
+  it('calls onQualityChange when position advances over 2nd quality change',
+      () => {
+        observer.addMediaQualityChange(quality1, 10);
+        emptyBuffer = false;
+        bufferStart = 10;
+        bufferEnd = 20;
+        observer.poll(10, false);
+        expect(onQualityChange).toHaveBeenCalledOnceMoreWith([quality1, 10]);
+        observer.addMediaQualityChange(quality2, 20);
+        bufferStart = 10;
+        bufferEnd = 30;
+        observer.poll(20, false);
+        expect(onQualityChange).toHaveBeenCalledOnceMoreWith([quality2, 20]);
+      });
+
+  it('calls onQualityChange when position moves back over a quality chanage',
+      () => {
+        observer.addMediaQualityChange(quality1, 10);
+        emptyBuffer = false;
+        bufferStart = 10;
+        bufferEnd = 20;
+        observer.addMediaQualityChange(quality2, 20);
+        bufferStart = 10;
+        bufferEnd = 30;
+        observer.poll(25, false);
+        expect(onQualityChange).toHaveBeenCalledOnceMoreWith([quality2, 25]);
+        observer.poll(15, false);
+        expect(onQualityChange).toHaveBeenCalledOnceMoreWith([quality1, 15]);
+      });
+
+  it('uses last applied quality when there are two at the same position',
+      () => {
+        observer.addMediaQualityChange(quality1, 10);
+        observer.addMediaQualityChange(quality2, 10);
+        emptyBuffer = false;
+        bufferStart = 10;
+        bufferEnd = 20;
+        observer.poll(15, false);
+        expect(onQualityChange).toHaveBeenCalledWith(quality2, 15);
+      });
+});

package/test/media/segment_reference_unit.js

@@ -38,14 +38,29 @@ describe('SegmentReference', () => {
 });
 
 describe('InitSegmentReference', () => {
+  const mediaQuality = {
+    bandwidth: 1,
+    audioSamplingRate: 444000,
+    codecs: 'my codec',
+    contentType: 'video',
+    frameRate: 30,
+    height: 720,
+    mimeType: 'mime type',
+    channelsCount: 2,
+    pixelAspectRatio: '1:1',
+    width: 1280,
+  };
+
   it('returns in getters values from constructor parameters', () => {
     const reference = new shaka.media.InitSegmentReference(
         /* getUris= */ () => ['x', 'y'],
         /* startByte= */ 4,
-        /* endByte= */ 5);
+        /* endByte= */ 5,
+        mediaQuality);
 
     expect(reference.getUris()).toEqual(['x', 'y']);
     expect(reference.getStartByte()).toBe(4);
     expect(reference.getEndByte()).toBe(5);
+    expect(reference.getMediaQuality()).toBe(mediaQuality);
   });
 });

package/test/media/streaming_engine_integration.js

@@ -60,7 +60,6 @@ describe('StreamingEngine', () => {
   /** @type {!shaka.media.StreamingEngine} */
   let streamingEngine;
 
-
   /** @type {shaka.extern.Variant} */
   let variant;
 
@@ -262,6 +261,7 @@ describe('StreamingEngine', () => {
 
   function createStreamingEngine() {
     const playerInterface = {
+      modifySegmentRequest: (request, segmentInfo) => {},
       getPresentationTime: () => playhead.getTime(),
       getBandwidthEstimate: () => 1e6,
       mediaSourceEngine: mediaSourceEngine,
@@ -270,6 +270,7 @@ describe('StreamingEngine', () => {
       onEvent: Util.spyFunc(onEvent),
       onManifestUpdate: () => {},
       onSegmentAppended: () => playhead.notifyOfBufferingChange(),
+      onInitSegmentAppended: () => {},
     };
     streamingEngine = new shaka.media.StreamingEngine(
         /** @type {shaka.extern.Manifest} */(manifest), playerInterface);

package/test/media/streaming_engine_unit.js

@@ -451,6 +451,7 @@ describe('StreamingEngine', () => {
         presentationTimeInSeconds != undefined,
         'All tests should have defined an initial presentation time by now!');
     const playerInterface = {
+      modifySegmentRequest: (request, segmentInfo) => {},
       getPresentationTime: () => presentationTimeInSeconds,
       getBandwidthEstimate: Util.spyFunc(getBandwidthEstimate),
       mediaSourceEngine: mediaSourceEngine,
@@ -459,6 +460,7 @@ describe('StreamingEngine', () => {
       onEvent: Util.spyFunc(onEvent),
       onManifestUpdate: Util.spyFunc(onManifestUpdate),
       onSegmentAppended: Util.spyFunc(onSegmentAppended),
+      onInitSegmentAppended: () => {},
     };
     streamingEngine = new shaka.media.StreamingEngine(
         /** @type {shaka.extern.Manifest} */(manifest), playerInterface);

package/test/net/http_plugin_unit.js

@@ -26,6 +26,9 @@ function httpPluginTests(usingFetch) {
   // A dummy progress callback.
   const progressUpdated = (elapsedMs, bytes, bytesRemaining) => {};
 
+  // A dummy headers callback.
+  const headersReceived = (headers) => {};
+
   /** @type {shaka.extern.RetryParameters} */
   let retryParameters;
 
@@ -168,7 +171,8 @@ function httpPluginTests(usingFetch) {
     request.method = 'POST';
     request.headers['BAZ'] = '123';
 
-    await plugin(request.uris[0], request, requestType, progressUpdated)
+    await plugin(
+        request.uris[0], request, requestType, progressUpdated, headersReceived)
         .promise;
 
     const actual = mostRecentRequest();
@@ -189,8 +193,8 @@ function httpPluginTests(usingFetch) {
       request.body = null;
       request.method = 'GET';
 
-      await plugin(request.uris[0], request, requestType, progressUpdated)
-          .promise;
+      await plugin(request.uris[0], request, requestType, progressUpdated,
+          headersReceived).promise;
 
       const actual = jasmine.Fetch.requests.mostRecent();
       expect(actual).toBeTruthy();
@@ -205,8 +209,8 @@ function httpPluginTests(usingFetch) {
 
       const request = shaka.net.NetworkingEngine.makeRequest(
           [uri], retryParameters, Util.spyFunc(streamDataCallback));
-      const response =
-          await plugin(uri, request, requestType, progressUpdated).promise;
+      const response = await plugin(
+          uri, request, requestType, progressUpdated, headersReceived).promise;
 
       expect(mostRecentRequest().url).toBe(uri);
       expect(response).toBeTruthy();
@@ -297,9 +301,9 @@ function httpPluginTests(usingFetch) {
     const request = shaka.net.NetworkingEngine.makeRequest(
         ['https://foo.bar/cache'], retryParameters);
 
-    const response =
-        await plugin(request.uris[0], request, requestType, progressUpdated)
-            .promise;
+    const response = await plugin(
+        request.uris[0], request, requestType, progressUpdated, headersReceived)
+        .promise;
     expect(response).toBeTruthy();
     expect(response.fromCache).toBe(true);
   });
@@ -312,8 +316,8 @@ function httpPluginTests(usingFetch) {
       uri = 'https://foo.bar/timeout';
       const request = shaka.net.NetworkingEngine.makeRequest(
           [uri], retryParameters);
-      const operation = plugin(
-          request.uris[0], request, requestType, progressUpdated);
+      const operation = plugin(request.uris[0], request, requestType,
+          progressUpdated, headersReceived);
 
       /** @type {jasmine.Fetch.RequestStub} */
       const actual = jasmine.Fetch.requests.mostRecent();
@@ -354,8 +358,8 @@ function httpPluginTests(usingFetch) {
       uri = 'https://foo.bar/';
       const request = shaka.net.NetworkingEngine.makeRequest(
           [uri], retryParameters);
-      operation = plugin(
-          request.uris[0], request, requestType, progressUpdated);
+      operation = plugin(request.uris[0], request, requestType, progressUpdated,
+          headersReceived);
       requestPromise = operation.promise;
     }
 
@@ -388,8 +392,8 @@ function httpPluginTests(usingFetch) {
   async function testSucceeds(uri, overrideUri) {
     const request = shaka.net.NetworkingEngine.makeRequest(
         [uri], retryParameters);
-    const response =
-        await plugin(uri, request, requestType, progressUpdated).promise;
+    const response = await plugin(
+        uri, request, requestType, progressUpdated, headersReceived).promise;
 
     expect(mostRecentRequest().url).toBe(uri);
     expect(response).toBeTruthy();
@@ -410,7 +414,8 @@ function httpPluginTests(usingFetch) {
     const request = shaka.net.NetworkingEngine.makeRequest(
         [uri], retryParameters);
 
-    const p = plugin(uri, request, requestType, progressUpdated).promise;
+    const p = plugin(
+        uri, request, requestType, progressUpdated, headersReceived).promise;
     if (expected.code == shaka.util.Error.Code.TIMEOUT) {
       jasmine.clock().tick(5000);
     }

package/test/offline/manifest_convert_unit.js

@@ -101,6 +101,7 @@ describe('ManifestConverter', () => {
           audioRobustness: 'very',
           videoRobustness: 'kinda_sorta',
           serverCertificate: new Uint8Array([1, 2, 3]),
+          serverCertificateUri: '',
           sessionType: '',
           initData: [{
             initData: new Uint8Array([4, 5, 6]),
@@ -316,6 +317,7 @@ describe('ManifestConverter', () => {
       appendWindowStart: 0,
       appendWindowEnd: Infinity,
       timestampOffset: 0,
+      tilesLayout: '',
     };
 
     return segment;

package/test/offline/storage_integration.js

@@ -22,10 +22,12 @@ goog.require('shaka.test.ManifestGenerator');
 goog.require('shaka.test.TestScheme');
 goog.require('shaka.test.Util');
 goog.require('shaka.util.AbortableOperation');
+goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
 goog.require('shaka.util.PlayerConfiguration');
 goog.require('shaka.util.PublicPromise');
+goog.require('shaka.util.Uint8ArrayUtils');
 goog.requireType('shaka.media.SegmentReference');
 
 /** @return {boolean} */
@@ -58,12 +60,16 @@ filterDescribe('Storage', storageSupport, () => {
   const manifestWithNonZeroStartUri = 'fake:manifest-with-non-zero-start';
   const manifestWithLiveTimelineUri = 'fake:manifest-with-live-timeline';
   const manifestWithAlternateSegmentsUri = 'fake:manifest-with-alt-segments';
+  const manifestWithVideoInitSegmentsUri =
+      'fake:manifest-with-video-init-segments';
 
+  const initSegmentUri = 'fake:init-segment';
   const segment1Uri = 'fake:segment-1';
   const segment2Uri = 'fake:segment-2';
   const segment3Uri = 'fake:segment-3';
   const segment4Uri = 'fake:segment-4';
 
+  const alternateInitSegmentUri = 'fake:alt-init-segment';
   const alternateSegment1Uri = 'fake:alt-segment-1';
   const alternateSegment2Uri = 'fake:alt-segment-2';
   const alternateSegment3Uri = 'fake:alt-segment-3';
@@ -147,15 +153,7 @@ filterDescribe('Storage', storageSupport, () => {
     }
   });
 
-  for (const useMediaCapabilities of [true, false]) {
-    const isEnabled = useMediaCapabilities ? 'enabled' : 'disabled';
-    filterDescribe('persistent license with MediaCapabilities ' + isEnabled,
-        drmStorageSupport, () => {
-          testPersistentLicense(useMediaCapabilities);
-        });
-  }
-
-  function testPersistentLicense(useMediaCapabilities) {
+  filterDescribe('persistent license', drmStorageSupport, () => {
     /** @type {!shaka.Player} */
     let player;
     /** @type {!shaka.offline.Storage} */
@@ -166,7 +164,6 @@ filterDescribe('Storage', storageSupport, () => {
       // networking engine.  This allows us to use Player.configure in these
       // tests.
       player = new shaka.Player();
-      player.configure({'useMediaCapabilities': useMediaCapabilities});
       storage = new shaka.offline.Storage(player);
     });
 
@@ -201,7 +198,7 @@ filterDescribe('Storage', storageSupport, () => {
       expect(manifest.offlineSessionIds.length).toBeTruthy();
 
       // PART 2 - Check that the licences are stored.
-      await withDrm(player, manifest, useMediaCapabilities, (drm) => {
+      await withDrm(player, manifest, (drm) => {
         return Promise.all(manifest.offlineSessionIds.map(async (session) => {
           const foundSession = await loadOfflineSession(drm, session);
           expect(foundSession).toBeTruthy();
@@ -213,7 +210,7 @@ filterDescribe('Storage', storageSupport, () => {
       await storage.remove(uri.toString());
 
       // PART 4 - Check that the licenses were removed.
-      const p = withDrm(player, manifest, useMediaCapabilities, (drm) => {
+      const p = withDrm(player, manifest, (drm) => {
         return Promise.all(manifest.offlineSessionIds.map(async (session) => {
           const notFoundSession = await loadOfflineSession(drm, session);
           expect(notFoundSession).toBeFalsy();
@@ -257,7 +254,7 @@ filterDescribe('Storage', storageSupport, () => {
       const storedContents = await storage.list();
       expect(storedContents).toEqual([]);
 
-      await withDrm(player, manifest, useMediaCapabilities, (drm) => {
+      await withDrm(player, manifest, (drm) => {
         return Promise.all(manifest.offlineSessionIds.map(async (session) => {
           const foundSession = await loadOfflineSession(drm, session);
           expect(foundSession).toBeTruthy();
@@ -270,7 +267,7 @@ filterDescribe('Storage', storageSupport, () => {
       expect(didRemoveAll).toBe(true);
 
       // PART 6 - Check that the licenses were removed.
-      const p = withDrm(player, manifest, useMediaCapabilities, (drm) => {
+      const p = withDrm(player, manifest, (drm) => {
         return Promise.all(manifest.offlineSessionIds.map(async (session) => {
           const notFoundSession = await loadOfflineSession(drm, session);
           expect(notFoundSession).toBeFalsy();
@@ -282,7 +279,7 @@ filterDescribe('Storage', storageSupport, () => {
           shaka.util.Error.Code.OFFLINE_SESSION_REMOVED));
       await expectAsync(p).toBeRejectedWith(expected);
     });
-  }
+  });
 
   describe('default track selection callback', () => {
     const PlayerConfiguration = shaka.util.PlayerConfiguration;
@@ -954,6 +951,46 @@ filterDescribe('Storage', storageSupport, () => {
       }
     });
 
+    it('can extract DRM info from segments', async () => {
+      const pssh1 =
+          '00000028' +                          // atom size
+          '70737368' +                          // atom type='pssh'
+          '00000000' +                          // v0, flags=0
+          'edef8ba979d64acea3c827dcd51d21ed' +  // system id (Widevine)
+          '00000008' +                          // data size
+          '0102030405060708';                   // data
+      const psshData1 = shaka.util.Uint8ArrayUtils.fromHex(pssh1);
+      const pssh2 =
+          '00000028' +                          // atom size
+          '70737368' +                          // atom type='pssh'
+          '00000000' +                          // v0, flags=0
+          'edef8ba979d64acea3c827dcd51d21ed' +  // system id (Widevine)
+          '00000008' +                          // data size
+          '1337420123456789';                   // data
+      const psshData2 = shaka.util.Uint8ArrayUtils.fromHex(pssh2);
+      netEngine.setResponseValue(initSegmentUri,
+          shaka.util.BufferUtils.toArrayBuffer(psshData1));
+      netEngine.setResponseValue(alternateInitSegmentUri,
+          shaka.util.BufferUtils.toArrayBuffer(psshData2));
+
+      const drm = new shaka.test.FakeDrmEngine();
+      const drmInfo = makeDrmInfo();
+      drmInfo.keySystem = 'com.widevine.alpha';
+      drm.setDrmInfo(drmInfo);
+      overrideDrmAndManifest(
+          storage,
+          drm,
+          makeManifestWithVideoInitSegments());
+
+      const stored = await storage.store(
+          manifestWithVideoInitSegmentsUri, noMetadata, fakeMimeType).promise;
+      goog.asserts.assert(stored.offlineUri != null, 'URI should not be null!');
+
+      // The manifest chooses the alternate stream, so expect only the alt init
+      // segment.
+      expect(drm.newInitData).toHaveBeenCalledWith('cenc', psshData2);
+    });
+
     it('can store multiple assets at once', async () => {
       // Block the network so that we won't finish the first store command.
       /** @type {!shaka.util.PublicPromise} */
@@ -1243,11 +1280,11 @@ filterDescribe('Storage', storageSupport, () => {
       goog.asserts.assert(
           content.offlineUri != null, 'URI should not be null!');
 
-      /**
-       * @type {!Array.<number>}
-       */
+      // We expect 5 progress events because there are 4 unique segments, plus
+      // the manifest.
+      /** @type {!Array.<number>}*/
       const progressSteps = [
-        0.111, 0.222, 0.333, 0.444, 0.555, 0.666, 0.777, 0.888, 1.0,
+        0.2, 0.4, 0.6, 0.8, 1,
       ];
 
       const progressCallback = (content, progress) => {
@@ -1408,6 +1445,62 @@ filterDescribe('Storage', storageSupport, () => {
     };
   }
 
+  /** @return {shaka.extern.Manifest} */
+  function makeManifestWithVideoInitSegments() {
+    const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+      manifest.presentationTimeline.setDuration(20);
+
+      manifest.addVariant(0, (variant) => {
+        variant.bandwidth = kbps(13);
+        variant.addVideo(1, (stream) => {
+          stream.bandwidth = kbps(13);
+          stream.size(100, 200);
+        });
+      });
+      manifest.addVariant(2, (variant) => {
+        variant.bandwidth = kbps(20);
+        variant.addVideo(3, (stream) => {
+          stream.bandwidth = kbps(20);
+          stream.size(200, 400);
+        });
+      });
+    });
+
+    const stream = manifest.variants[0].video;
+    goog.asserts.assert(stream, 'The first stream should exist');
+    stream.encrypted = true;
+    const init = new shaka.media.InitSegmentReference(
+        () => [initSegmentUri], 0, null);
+    const refs = [
+      makeReference(segment1Uri, 0, 1),
+      makeReference(segment2Uri, 1, 2),
+      makeReference(segment3Uri, 2, 3),
+      makeReference(segment4Uri, 3, 4),
+    ];
+    for (const ref of refs) {
+      ref.initSegmentReference = init;
+    }
+    overrideSegmentIndex(stream, refs);
+
+    const streamAlt = manifest.variants[1].video;
+    goog.asserts.assert(streamAlt, 'The second stream should exist');
+    streamAlt.encrypted = true;
+    const initAlt = new shaka.media.InitSegmentReference(
+        () => [alternateInitSegmentUri], 0, null);
+    const refsAlt = [
+      makeReference(alternateSegment1Uri, 0, 1),
+      makeReference(alternateSegment2Uri, 1, 2),
+      makeReference(alternateSegment3Uri, 2, 3),
+      makeReference(alternateSegment4Uri, 3, 4),
+    ];
+    for (const ref of refsAlt) {
+      ref.initSegmentReference = initAlt;
+    }
+    overrideSegmentIndex(streamAlt, refsAlt);
+
+    return manifest;
+  }
+
   /** @return {shaka.extern.Manifest} */
   function makeManifestWithPerStreamBandwidth() {
     const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
@@ -1598,6 +1691,7 @@ filterDescribe('Storage', storageSupport, () => {
       keyIds: null,
       sessionType: 'temporary',
       serverCertificate: null,
+      serverCertificateUri: '',
       audioRobustness: 'HARDY',
       videoRobustness: 'OTHER',
     };
@@ -1620,6 +1714,8 @@ filterDescribe('Storage', storageSupport, () => {
           makeManifestWithLiveTimeline();
       this.map_[manifestWithAlternateSegmentsUri] =
           makeManifestWithAlternateSegments();
+      this.map_[manifestWithVideoInitSegmentsUri] =
+          makeManifestWithVideoInitSegments();
     }
 
     /** @override */
@@ -1681,11 +1777,10 @@ filterDescribe('Storage', storageSupport, () => {
   /**
    * @param {!shaka.Player} player
    * @param {shaka.extern.Manifest} manifest
-   * @param {boolean} useMediaCapabilities
    * @param {function(!shaka.media.DrmEngine):Promise} action
    * @return {!Promise}
    */
-  async function withDrm(player, manifest, useMediaCapabilities, action) {
+  async function withDrm(player, manifest, action) {
     const net = player.getNetworkingEngine();
     goog.asserts.assert(net, 'Player should have a net engine right now');
 
@@ -1703,8 +1798,7 @@ filterDescribe('Storage', storageSupport, () => {
     try {
       drm.configure(player.getConfiguration().drm);
       const variants = manifest.variants;
-      await drm.initForStorage(variants, /* usePersistentLicenses= */ true,
-          useMediaCapabilities);
+      await drm.initForStorage(variants, /* usePersistentLicenses= */ true);
       await action(drm);
     } finally {
       await drm.destroy();