shaka-player 2.5.4 → 2.5.5

package/lib/util/pssh.js

@@ -104,3 +104,44 @@ shaka.util.Pssh.prototype.parseBox_ = function(box) {
     shaka.log.warning('Mismatch between box size and data size!');
   }
 };
+
+
+/**
+ * Creates a pssh blob from the given system ID and data.
+ *
+ * @param {!Uint8Array} data
+ * @param {!Uint8Array} systemId
+ * @return {!Uint8Array}
+ */
+shaka.util.Pssh.createPssh = function(data, systemId) {
+  const dataLength = data.length;
+  const psshSize = 0x4 + 0x4 + 0x4 + systemId.length + 0x4 + dataLength;
+
+  /** @type {!ArrayBuffer} */
+  const psshBoxBuffer = new ArrayBuffer(psshSize);
+
+  /** @type {!Uint8Array} */
+  const psshBox = new Uint8Array(psshBoxBuffer);
+
+  /** @type {!DataView} */
+  const psshData = new DataView(psshBoxBuffer);
+
+  let byteCursor = 0;
+  psshData.setUint32(byteCursor, psshSize);
+  byteCursor += 0x4;
+  psshData.setUint32(byteCursor, 0x70737368);  // 'pssh'
+  byteCursor += 0x4;
+  psshData.setUint32(byteCursor, 0);  // flags
+  byteCursor += 0x4;
+  psshBox.set(systemId, byteCursor);
+  byteCursor += systemId.length;
+  psshData.setUint32(byteCursor, dataLength);
+  byteCursor += 0x4;
+  psshBox.set(data, byteCursor);
+  byteCursor += dataLength;
+
+  goog.asserts.assert(byteCursor === psshSize,
+      'MS PRO invalid length.');
+
+  return psshBox;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "2.5.4",
+  "version": "2.5.5",
   "homepage": "https://github.com/google/shaka-player",
   "author": "Google",
   "maintainers": [
@@ -39,7 +39,7 @@
     "karma-safari-launcher": "^1.0.0",
     "karma-sourcemap-loader": "^0.3.7",
     "karma-spec-reporter": "0.0.32",
-    "karma-webdriver-launcher": "^1.0.5",
+    "karma-webdriver-launcher": "^1.0.7",
     "less": "^3.9.0",
     "less-plugin-clean-css": "^1.5.1",
     "material-design-lite": "^1.3.0",
@@ -48,8 +48,9 @@
     "promise-polyfill": "<8.1.1",
     "rimraf": "^2.6.3",
     "sprintf-js": "^1.1.2",
+    "stylelint": "github:theodab/stylelint",
+    "stylelint-config-standard": "^18.3.0",
     "tippy.js": "^4.3.1",
-    "wd": "^1.11.2",
     "which": "^1.3.1"
   },
   "main": "dist/shaka-player.compiled.js",

package/shaka-player.uncompiled.js

@@ -64,8 +64,11 @@ goog.require('shaka.text.TextEngine');
 goog.require('shaka.text.TtmlTextParser');
 goog.require('shaka.text.VttTextParser');
 goog.require('shaka.ui.Controls');
+goog.require('shaka.ui.PlayButton');
+goog.require('shaka.ui.SettingsMenu');
 goog.require('shaka.ui.OverflowMenu');
 goog.require('shaka.ui.AudioLanguageSelection');
+goog.require('shaka.ui.BigPlayButton');
 goog.require('shaka.ui.CastButton');
 goog.require('shaka.ui.Element');
 goog.require('shaka.ui.FastForwardButton');
@@ -74,7 +77,7 @@ goog.require('shaka.ui.Localization');
 goog.require('shaka.ui.MuteButton');
 goog.require('shaka.ui.Overlay');
 goog.require('shaka.ui.PipButton');
-goog.require('shaka.ui.PlayPauseButton');
+goog.require('shaka.ui.SmallPlayButton');
 goog.require('shaka.ui.PresentationTimeTracker');
 goog.require('shaka.ui.ResolutionSelection');
 goog.require('shaka.ui.RewindButton');
@@ -83,4 +86,5 @@ goog.require('shaka.ui.TextSelection');
 goog.require('shaka.ui.VolumeBar');
 goog.require('shaka.util.Dom');
 goog.require('shaka.util.Error');
+goog.require('shaka.util.FairPlayUtils');
 goog.require('shaka.util.Iterables');

package/test/dash/dash_parser_content_protection_unit.js

@@ -68,7 +68,8 @@ describe('DashParser ContentProtection', function() {
       adaptationSetLines, representation1Lines, representation2Lines) {
     let template = [
       '<MPD xmlns="urn:mpeg:DASH:schema:MPD:2011"',
-      '    xmlns:cenc="urn:mpeg:cenc:2013">',
+      '    xmlns:cenc="urn:mpeg:cenc:2013"',
+      '    xmlns:mspr="urn:microsoft:playready">',
       '  <Period duration="PT30S">',
       '    <SegmentTemplate media="s.mp4" duration="2" />',
       '    <AdaptationSet mimeType="video/mp4" codecs="avc1.4d401f">',
@@ -298,6 +299,39 @@ describe('DashParser ContentProtection', function() {
     await testDashParser(source, expected);
   });
 
+  it('extracts embedded PSSHs with mspr:pro', async () => {
+    const source = buildManifestText([
+      // AdaptationSet lines
+      '<ContentProtection',
+      '  schemeIdUri="urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95">',
+      '  <mspr:pro>UGxheXJlYWR5</mspr:pro>',
+      '</ContentProtection>',
+    ], [], []);
+    const expected = buildExpectedManifest([
+      buildDrmInfo('com.microsoft.playready', [], [
+        'AAAAKXBzc2gAAAAAmgTweZhAQoarkuZb4IhflQAAAAlQbGF5cmVhZHk=',
+      ]),
+    ]);
+    await testDashParser(source, expected);
+  });
+
+  it('extracts embedded PSSHs and prefer cenc:pssh over mspr:pro', async () => {
+    const source = buildManifestText([
+      // AdaptationSet lines
+      '<ContentProtection',
+      '  schemeIdUri="urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95">',
+      '  <cenc:pssh>bm8gaHVtYW4gY2FuIHJlYWQgYmFzZTY0IGRpcmVjdGx5</cenc:pssh>',
+      '  <mspr:pro>ZmFrZSBQbGF5cmVhZHkgUFJP</mspr:pro>',
+      '</ContentProtection>',
+    ], [], []);
+    const expected = buildExpectedManifest([
+      buildDrmInfo('com.microsoft.playready', [], [
+        'bm8gaHVtYW4gY2FuIHJlYWQgYmFzZTY0IGRpcmVjdGx5',
+      ]),
+    ]);
+    await testDashParser(source, expected);
+  });
+
   it('assumes all known key systems for generic CENC', async () => {
     let source = buildManifestText([
       // AdaptationSet lines

package/test/dash/dash_parser_manifest_unit.js

@@ -1244,4 +1244,35 @@ describe('DashParser Manifest', function() {
     expect(presentationDelay).not.toBeNaN();
     expect(presentationDelay).toBe(config.dash.defaultPresentationDelay);
   });
+
+  it('converts Accessibility element to "kind"', async () => {
+    const manifestText = [
+      '<MPD minBufferTime="PT75S">',
+      '  <Period id="1" duration="PT30S">',
+      '    <AdaptationSet id="1" contentType="text">',
+      '      <Accessibility schemeIdUri="urn:mpeg:dash:role:2011" ',
+      '          value="captions" />',
+      '      <Accessibility schemeIdUri="urn:mpeg:dash:role:2011" ',
+      '          value="foo" />',
+      '      <Accessibility schemeIdUri="foobar" value="bar" />',
+      '      <Representation id="text-en" mimeType="text/webvtt">',
+      '        <BaseURL>t-en.vtt</BaseURL>',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '    <AdaptationSet id="1" mimeType="video/mp4">',
+      '      <Representation id="video-sd" width="640" height="480">',
+      '        <BaseURL>v-sd.mp4</BaseURL>',
+      '        <SegmentBase indexRange="100-200" />',
+      '      </Representation>',
+      '    </AdaptationSet>',
+      '  </Period>',
+      '</MPD>',
+    ].join('\n');
+
+    fakeNetEngine.setResponseText('dummy://foo', manifestText);
+    const manifest = await parser.start('dummy://foo', playerInterface);
+    const textStream = manifest.periods[0].textStreams[0];
+    expect(textStream.roles).toEqual(['captions', 'foo']);
+    expect(textStream.kind).toBe('caption');
+  });
 });

package/test/hls/hls_live_unit.js

@@ -273,12 +273,18 @@ describe('HlsParser live', function() {
       });
 
       it('updates all streams', function(done) {
+        const masterlist = [
+          '#EXTM3U\n',
+          '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1",AUDIO="aud1",',
+          'RESOLUTION=960x540,FRAME-RATE=60\n',
+          'video\n',
+        ].join('');
         const audio = [
           '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="eng",',
           'URI="audio"\n',
         ].join('');
 
-        let masterWithAudio = master + audio;
+        let masterWithAudio = masterlist + audio;
         let ref1 = ManifestParser.makeReference('test:/main.mp4',
                                                 0, 2, 4);
         let ref2 = ManifestParser.makeReference('test:/main2.mp4',

package/test/hls/hls_parser_unit.js

@@ -1107,6 +1107,56 @@ describe('HlsParser', function() {
         .catch(fail).then(done);
   });
 
+  it('drops failed text streams when configured to', async () => {
+    const master = [
+      '#EXTM3U\n',
+      '#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="sub1",LANGUAGE="eng",',
+      'URI="text"\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1,vtt",',
+      'RESOLUTION=960x540,FRAME-RATE=60,SUBTITLES="sub1"\n',
+      'video\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 textMedia = [
+      '#EXTM3U\n',
+      '#EXT-X-PLAYLIST-TYPE:VOD\n',
+      '#EXTINF:5,\n',
+      '#EXT-X-BYTERANGE:121090@616\n',
+      'main.foo',
+    ].join('');
+
+    /* eslint-disable indent */
+    const manifest = new shaka.test.ManifestGenerator()
+        .anyTimeline()
+        .addPeriod(0)
+          .addPartialVariant()
+            .addPartialStream(ContentType.VIDEO)
+        .build();
+    /* eslint-enable indent */
+
+    fakeNetEngine
+        .setResponseText('test:/master', master)
+        .setResponseText('test:/audio', media)
+        .setResponseText('test:/video', media)
+        .setResponseText('test:/text', textMedia)
+        .setResponseText('test:/main.foo', '')
+        .setResponseValue('test:/init.mp4', initSegmentData)
+        .setResponseValue('test:/main.mp4', segmentData);
+
+    config.hls.ignoreTextStreamFailures = true;
+    const actual = await parser.start('test:/master', playerInterface);
+    expect(actual).toEqual(manifest);
+  });
+
   it('parses video described by a media tag', async () => {
     const master = [
       '#EXTM3U\n',

package/test/media/media_source_engine_integration.js

@@ -193,6 +193,18 @@ describe('MediaSourceEngine', function() {
     expect(mediaSource.duration).toBeCloseTo(30);
   });
 
+  it('does not throw if endOfStrem called more than once', async () => {
+    const initObject = new Map();
+    initObject.set(ContentType.VIDEO, getFakeStream(metadata.video));
+    await mediaSourceEngine.init(initObject, false);
+    await mediaSourceEngine.setDuration(presentationDuration);
+    await appendInit(ContentType.VIDEO);
+    await append(ContentType.VIDEO, 1);
+    // Call endOfStream twice. There should be no exception.
+    await mediaSourceEngine.endOfStream();
+    await mediaSourceEngine.endOfStream();
+  });
+
   it('queues operations', function(done) {
     let resolutionOrder = [];
     let requests = [];

package/test/media/playhead_unit.js

@@ -212,6 +212,7 @@ describe('Playhead', function() {
 
       expect(video.addEventListener).toHaveBeenCalledWith(
           'seeking', jasmine.any(Function), jasmine.anything());
+      video.on['seeking']();
 
       expect(playhead.getTime()).toBe(5);
       expect(video.currentTime).toBe(5);
@@ -239,6 +240,7 @@ describe('Playhead', function() {
           Util.spyFunc(onSeek),
           Util.spyFunc(onEvent));
 
+      video.on['seeking']();
       expect(playhead.getTime()).toBe(5);
       expect(video.currentTime).toBe(5);
 

package/test/player_external.js

@@ -89,7 +89,7 @@ describe('Player', () => {
 
       let wit = asset.focus ? fit : it;
       wit(testName, async () => {
-        if (asset.drm.length &&
+        if (!asset.isClear() &&
             !asset.drm.some((keySystem) => support.drm[keySystem])) {
           pending('None of the required key systems are supported.');
         }
@@ -102,7 +102,8 @@ describe('Player', () => {
           if (asset.features.includes(Feature.MP4)) {
             mimeTypes.push('video/mp4');
           }
-          if (!mimeTypes.some((type) => support.media[type])) {
+          if (mimeTypes.length &&
+              !mimeTypes.some((type) => support.media[type])) {
             pending('None of the required MIME types are supported.');
           }
         }

package/test/player_integration.js

@@ -464,6 +464,81 @@ describe('Player', function() {
       }).catch(fail).then(done);
     });
   });
+
+  describe('tracks', () => {
+    // This is a regression test for b/138941217, in which tracks briefly
+    // vanished during the loading process.  On Chromecast devices, where the
+    // timing is very different from on desktop, this could occur such that
+    // there were no tracks after load() is resolved.
+    // This is an integration test so that we can check the behavior of the
+    // Player against actual platform behavior on all supported platforms.
+    it('remain available at every stage of loading', async () => {
+      let tracksFound = false;
+
+      /**
+       * @param {string} when When the check takes place.
+       *
+       * Will fail the test if tracks disappear after they first become
+       * available.
+       */
+      const checkTracks = (when) => {
+        // If tracks have already been found, expect them to still be found.
+        const tracksNow = player.getVariantTracks().length != 0;
+        if (tracksFound) {
+          expect(tracksNow).toBe(true);
+        } else {
+          // If tracks are now found, they should not, at any point during
+          // the loading process, disappear again.
+          if (tracksNow) {
+            tracksFound = true;
+          }
+        }
+        shaka.log.debug(
+            'checkTracks', when,
+            'tracksFound=', tracksFound,
+            'tracksNow=', tracksNow);
+      };
+
+      /** @param {Event} event */
+      const checkOnEvent = (event) => {
+        checkTracks(event.type + ' event');
+      };
+
+      // On each of these events, we will notice when tracks first appear, and
+      // verify that they never disappear at any point in the loading sequence.
+      eventManager.listen(video, 'canplay', checkOnEvent);
+      eventManager.listen(video, 'canplaythrough', checkOnEvent);
+      eventManager.listen(video, 'durationchange', checkOnEvent);
+      eventManager.listen(video, 'emptied', checkOnEvent);
+      eventManager.listen(video, 'loadeddata', checkOnEvent);
+      eventManager.listen(video, 'loadedmetadata', checkOnEvent);
+      eventManager.listen(video, 'loadstart', checkOnEvent);
+      eventManager.listen(video, 'pause', checkOnEvent);
+      eventManager.listen(video, 'play', checkOnEvent);
+      eventManager.listen(video, 'playing', checkOnEvent);
+      eventManager.listen(video, 'seeked', checkOnEvent);
+      eventManager.listen(video, 'seeking', checkOnEvent);
+      eventManager.listen(video, 'stalled', checkOnEvent);
+      eventManager.listen(video, 'waiting', checkOnEvent);
+      eventManager.listen(player, 'trackschanged', checkOnEvent);
+
+      const waiter = (new shaka.test.Waiter(eventManager)).timeoutAfter(10);
+      const canPlayThrough = waiter.waitForEvent(video, 'canplaythrough');
+
+      // Important: use a stream that starts somewhere other than zero, so that
+      // the video element's time is initially different from the start time of
+      // playback, and there is no content at time zero.
+      await player.load('test:sintel_start_at_3_compiled', 5);
+      shaka.log.debug('load resolved');
+
+      // When load is resolved(), tracks should definitely exist.
+      expect(tracksFound).toBe(true);
+
+      // Let the test keep running until we can play through.  In the original
+      // bug, tracks would disappear _after_ load() on some platforms.
+      await canPlayThrough;
+    });
+  });
 });
 
 // TODO(vaage): Try to group the stat tests together.

package/test/test/externs/jasmine.js

@@ -187,6 +187,12 @@ jasmine.Matchers.prototype.toHaveBeenCalledOnceMore = function() {};
  */
 jasmine.Matchers.prototype.toHaveBeenCalledOnceMoreWith = function(args) {};
 
+/**
+ * @param {string} message
+ * @return {!jasmine.Matchers}
+ */
+jasmine.Matchers.prototype.withContext = function(message) {};
+
 
 /** @type {!jasmine.MatchersAsync} */
 jasmine.MatchersAsync.prototype.not;

package/test/test/util/test_scheme.js

@@ -126,6 +126,37 @@ shaka.test.TestScheme.DATA = {
     duration: 30,
   },
 
+  // Like 'sintel' above, but with a non-zero period start time.
+  // This helps expose edge cases around startup and live streams.
+  'sintel_start_at_3': {
+    periodStart: 3,
+    video: {
+      initSegmentUri: '/base/test/test/assets/sintel-video-init.mp4',
+      mdhdOffset: 0x1ba,
+      segmentUri: '/base/test/test/assets/sintel-video-segment.mp4',
+      tfdtOffset: 0x38,
+      segmentDuration: 10,
+      presentationTimeOffset: 0,
+      mimeType: 'video/mp4',
+      codecs: 'avc1.42c01e',
+    },
+    audio: {
+      initSegmentUri: '/base/test/test/assets/sintel-audio-init.mp4',
+      mdhdOffset: 0x1b6,
+      segmentUri: '/base/test/test/assets/sintel-audio-segment.mp4',
+      tfdtOffset: 0x3c,
+      segmentDuration: 10.005,
+      presentationTimeOffset: 0,
+      mimeType: 'audio/mp4',
+      codecs: 'mp4a.40.2',
+    },
+    text: {
+      uri: '/base/test/test/assets/text-clip.vtt',
+      mimeType: 'text/vtt',
+    },
+    duration: 30,
+  },
+
   // Like 'sintel' above, but with languages and delayed setup.
   // These extra features help expose some edge cases.
   'sintel_realistic': {
@@ -477,7 +508,7 @@ shaka.test.TestScheme.createManifests = function(shaka, suffix) {
 
     let gen = new windowShaka.test.ManifestGenerator(shaka)
         .setPresentationDuration(data.duration)
-        .addPeriod(/* startTime= */ 0)
+        .addPeriod(/* startTime= */ data.periodStart || 0)
         .addVariant(0);
 
     if (data[ContentType.VIDEO]) {

package/test/test/util/ui_utils.js

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+goog.provide('shaka.test.UiUtils');
+
+
+shaka.test.UiUtils = class {
+  /**
+   * Simulates a native event (e.g. 'click') on the given element.
+   *
+   * @param {EventTarget} target
+   * @param {string} name
+   */
+  static simulateEvent(target, name) {
+    const type = {
+      'click': 'MouseEvent',
+      'dblclick': 'MouseEvent',
+    }[name] || 'CustomEvent';
+
+    // Note we can't use the MouseEvent constructor since it isn't supported on
+    // IE11.
+    const event = document.createEvent(type);
+    event.initEvent(name, true, true);
+    target.dispatchEvent(event);
+  }
+};