shaka-player 3.2.2 → 3.3.0

package/lib/offline/stored_content_utils.js

@@ -47,6 +47,7 @@ shaka.offline.StoredContentUtils = class {
       expiration: Infinity,
       tracks: tracks,
       appMetadata: metadata,
+      isIncomplete: false,
     };
 
     return content;
@@ -87,6 +88,7 @@ shaka.offline.StoredContentUtils = class {
       expiration: manifestDB.expiration,
       tracks: tracks,
       appMetadata: metadata,
+      isIncomplete: (manifestDB.isIncomplete || false),
     };
 
     return content;

package/lib/player.js

@@ -22,6 +22,7 @@ goog.require('shaka.media.PlayRateController');
 goog.require('shaka.media.Playhead');
 goog.require('shaka.media.PlayheadObserverManager');
 goog.require('shaka.media.PreferenceBasedCriteria');
+goog.require('shaka.media.QualityObserver');
 goog.require('shaka.media.RegionObserver');
 goog.require('shaka.media.RegionTimeline');
 goog.require('shaka.media.SegmentIndex');
@@ -36,6 +37,7 @@ goog.require('shaka.text.UITextDisplayer');
 goog.require('shaka.text.WebVttGenerator');
 goog.require('shaka.util.AbortableOperation');
 goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.CmcdManager');
 goog.require('shaka.util.ConfigUtils');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
@@ -106,6 +108,32 @@ goog.requireType('shaka.routing.Payload');
  */
 
 
+/**
+ * @event shaka.Player.DownloadFailed
+ * @description Fired when a download has failed, for any reason.
+ *   'downloadfailed'
+ * @property {!shaka.extern.Request} request
+ * @property {?shaka.util.Error} error
+ * @param {number} httpResponseCode
+ * @param {boolean} aborted
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.DownloadHeadersReceived
+ * @description Fired when the networking engine has received the headers for
+ *    a download, but before the body has been downloaded.
+ *    If the HTTP plugin being used does not track this information, this event
+ *    will default to being fired when the body is received, instead.
+ * @property {!Object.<string, string>} headers
+ * @property {!shaka.extern.Request} request
+ * @property {!shaka.net.NetworkingEngine.RequestType} type
+ *   'downloadheadersreceived'
+ * @exportDoc
+ */
+
+
 /**
  * @event shaka.Player.DrmSessionUpdateEvent
  * @description Fired when the CDM has accepted the license response.
@@ -147,6 +175,21 @@ goog.requireType('shaka.routing.Payload');
  * @exportDoc
  */
 
+/**
+ * @event shaka.Player.MediaQualityChangedEvent
+ * @description Fired when the media quality changes at the playhead.
+ * That may be caused by an adaptation change or a DASH period transition.
+ * Separate events are emitted for audio and video contentTypes.
+ * This is supported for only DASH streams at this time.
+ * @property {string} type
+ *   'mediaqualitychanged'
+ * @property {shaka.extern.MediaQualityInfo} mediaQuality
+ *   Information about media quality at the playhead position.
+ * @property {number} position
+ *   The playhead position.
+ * @exportDoc
+ */
+
 
 /**
  * @event shaka.Player.BufferingEvent
@@ -441,6 +484,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {shaka.media.RegionTimeline} */
     this.regionTimeline_ = null;
 
+    /** @private {shaka.util.CmcdManager} */
+    this.cmcdManager_ = null;
+
+    /** @private {shaka.media.QualityObserver} */
+    this.qualityObserver_ = null;
+
     /** @private {shaka.media.StreamingEngine} */
     this.streamingEngine_ = null;
 
@@ -507,6 +556,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {!Array.<function():(!Promise|undefined)>} */
     this.cleanupOnUnload_ = [];
 
+    /**
+     * This playback start position will be used when
+     * <code>updateStartTime()</code> has been called to provide an updated
+     * start position during the media loading process.
+     *
+     * @private {?number}
+     */
+    this.updatedStartTime_ = null;
+
     if (dependencyInjector) {
       dependencyInjector(this);
     }
@@ -723,6 +781,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.config_ = null;
     this.stats_ = null;
     this.videoContainer_ = null;
+    this.cmcdManager_ = null;
 
     if (this.networkingEngine_) {
       await this.networkingEngine_.destroy();
@@ -1020,6 +1079,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return this.wrapWalkerListenersWithPromise_(events);
   }
 
+  /**
+   * Provides a way to update the stream start position during the media loading
+   * process. Can for example be called from the <code>manifestparsed</code>
+   * event handler to update the start position based on information in the
+   * manifest.
+   *
+   * @param {number} startTime
+   * @export
+   */
+  updateStartTime(startTime) {
+    this.updatedStartTime_ = startTime;
+  }
+
   /**
    * Tell the player to load the content at <code>assetUri</code> and start
    * playback at <code>startTime</code>. Before calling <code>load</code>,
@@ -1040,6 +1112,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @export
    */
   load(assetUri, startTime, mimeType) {
+    this.updatedStartTime_ = null;
+
     // Do not allow the player to be used after |destroy| is called.
     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
       return Promise.reject(this.createAbortLoadError_());
@@ -1093,6 +1167,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // before we allow calls to |updateStateHistory|.
     this.stats_ = new shaka.util.Stats();
 
+    // Create the CMCD manager so client data can be attached to all requests
+    this.cmcdManager_ = this.createCmcd_();
+
     // Load's request is a little different, so we can't use our normal
     // listeners-to-promise method. It is the only request where we may skip the
     // request, so we need to set the on skip callback to reject with a specific
@@ -1594,6 +1671,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     goog.asserts.assert(
         this.networkingEngine_,
         'Need networking engine to parse manifest.');
+    goog.asserts.assert(
+        this.cmcdManager_,
+        'Need CMCD manager to populate manifest request data.');
     goog.asserts.assert(
         this.config_,
         'Need player config to parse manifest.');
@@ -1617,9 +1697,23 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.adManager_.onDashTimedMetadata(region);
       }
     });
+    this.qualityObserver_ = null;
+    if (this.config_.streaming.observeQualityChanges) {
+      this.qualityObserver_ = new shaka.media.QualityObserver(
+          () => this.getBufferedInfo());
+      this.qualityObserver_.setListeners((mediaQualityInfo, position) => {
+        this.onMediaQualityChange_(mediaQualityInfo, position);
+      });
+    }
 
     const playerInterface = {
       networkingEngine: networkingEngine,
+      modifyManifestRequest: (request, manifestInfo) => {
+        this.cmcdManager_.applyManifestData(request, manifestInfo);
+      },
+      modifySegmentRequest: (request, segmentInfo) => {
+        this.cmcdManager_.applySegmentData(request, segmentInfo);
+      },
       filter: (manifest) => this.filterManifest_(manifest),
       makeTextStreamsForClosedCaptions: (manifest) => {
         return this.makeTextStreamsForClosedCaptions_(manifest);
@@ -1780,6 +1874,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // something we are now depending on.
     has.startTime = wants.startTime;
 
+    // If updateStartTime() has been called since load() was invoked use the
+    // requested startTime
+    if (this.updatedStartTime_ != null) {
+      has.startTime = this.updatedStartTime_;
+      this.updatedStartTime_ = null;
+    }
+
     // Store a reference to values in |has| after asserting so that closure will
     // know that they will still be non-null between calls to await.
     const mediaElement = has.mediaElement;
@@ -2177,9 +2278,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           this.video_.textTracks, 'change', () => this.onTracksChanged_());
     }
 
+    const extension = shaka.media.ManifestParser.getExtension(has.uri);
+    const mimeType =
+      shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_[extension];
+
     // By setting |src| we are done "loading" with src=. We don't need to set
     // the current time because |playhead| will do that for us.
-    has.mediaElement.src = has.uri;
+    has.mediaElement.src = this.cmcdManager_.appendSrcData(has.uri, mimeType);
 
     // Tizen 3 / WebOS won't load anything unless you call load() explicitly,
     // no matter the value of the preload attribute.  This is harmful on some
@@ -2509,8 +2614,30 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.abrManager_.segmentDownloaded(deltaTimeMs, bytesDownloaded);
       }
     };
+    /** @type {shaka.net.NetworkingEngine.OnHeadersReceived} */
+    const onHeadersReceived_ = (headers, request, requestType) => {
+      // Release a 'downloadheadersreceived' event.
+      const name = shaka.Player.EventName.DownloadHeadersReceived;
+      const data = new Map()
+          .set('headers', headers)
+          .set('request', request)
+          .set('requestType', requestType);
+      this.dispatchEvent(this.makeEvent_(name, data));
+    };
+    /** @type {shaka.net.NetworkingEngine.OnDownloadFailed} */
+    const onDownloadFailed_ = (request, error, httpResponseCode, aborted) => {
+      // Release a 'downloadfailed' event.
+      const name = shaka.Player.EventName.DownloadFailed;
+      const data = new Map()
+          .set('request', request)
+          .set('error', error)
+          .set('httpResponseCode', httpResponseCode)
+          .set('aborted', aborted);
+      this.dispatchEvent(this.makeEvent_(name, data));
+    };
 
-    return new shaka.net.NetworkingEngine(onProgressUpdated_);
+    return new shaka.net.NetworkingEngine(
+        onProgressUpdated_, onHeadersReceived_, onDownloadFailed_);
   }
 
   /**
@@ -2566,7 +2693,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Now that we have all our observers, create a manager for them.
     const manager = new shaka.media.PlayheadObserverManager(this.video_);
     manager.manage(regionObserver);
-
+    if (this.qualityObserver_) {
+      manager.manage(this.qualityObserver_);
+    }
     return manager;
   }
 
@@ -2682,6 +2811,27 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         mediaElement, closedCaptionsParser, textDisplayer, onMetadata);
   }
 
+  /**
+   * Create a new CMCD manager.
+   *
+   * @private
+   */
+  createCmcd_() {
+    const abr = this.abrManager_;
+
+    /** @type {shaka.util.CmcdManager.PlayerInterface} */
+    const playerInterface = {
+      getBandwidthEstimate: () => abr ? abr.getBandwidthEstimate() : NaN,
+      getBufferedInfo: () => this.getBufferedInfo(),
+      getCurrentTime: () => this.video_ ? this.video_.currentTime : 0,
+      getManifest: () => this.manifest_,
+      getPlaybackRate: () => this.getPlaybackRate(),
+      isLive: () => this.isLive(),
+    };
+
+    return new shaka.util.CmcdManager(playerInterface, this.config_.cmcd);
+  }
+
   /**
    * Creates a new instance of StreamingEngine.  This can be replaced by tests
    * to create fake instances instead.
@@ -2691,19 +2841,28 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   createStreamingEngine() {
     goog.asserts.assert(
         this.playhead_ && this.abrManager_ && this.mediaSourceEngine_ &&
-        this.manifest_,
+        this.cmcdManager_ && this.manifest_,
         'Must not be destroyed');
 
     /** @type {shaka.media.StreamingEngine.PlayerInterface} */
     const playerInterface = {
       getPresentationTime: () => this.playhead_.getTime(),
       getBandwidthEstimate: () => this.abrManager_.getBandwidthEstimate(),
+      modifySegmentRequest: (request, segmentInfo) => {
+        this.cmcdManager_.applySegmentData(request, segmentInfo);
+      },
       mediaSourceEngine: this.mediaSourceEngine_,
       netEngine: this.networkingEngine_,
       onError: (error) => this.onError_(error),
       onEvent: (event) => this.dispatchEvent(event),
       onManifestUpdate: () => this.onManifestUpdate_(),
       onSegmentAppended: () => this.onSegmentAppended_(),
+      onInitSegmentAppended: (position, initSegment) => {
+        const mediaQuality = initSegment.getMediaQuality();
+        if (mediaQuality && this.qualityObserver_) {
+          this.qualityObserver_.addMediaQualityChange(mediaQuality, position);
+        }
+      },
     };
 
     return new shaka.media.StreamingEngine(this.manifest_, playerInterface);
@@ -4267,7 +4426,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
       const trackElement =
         /** @type {!HTMLTrackElement} */(document.createElement('track'));
-      trackElement.src = uri;
+      trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
       trackElement.label = label || '';
       trackElement.kind = kind;
       trackElement.srclang = language;
@@ -4605,7 +4764,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
     const trackElement =
       /** @type {!HTMLTrackElement} */(document.createElement('track'));
-    trackElement.src = uri;
+    trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
     trackElement.label = label;
     trackElement.kind = kind;
     trackElement.srclang = language;
@@ -4634,6 +4793,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
     request.method = 'GET';
 
+    this.cmcdManager_.applyTextData(request);
+
     const response = await netEngine.request(type, request).promise;
 
     return response.data;
@@ -5031,6 +5192,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     if (loaded) {
       this.playRateController_.setBuffering(isBuffering);
+      if (this.cmcdManager_) {
+        this.cmcdManager_.setBuffering(isBuffering);
+      }
       this.updateStateHistory_();
     }
 
@@ -5505,6 +5669,38 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
+  /**
+   * When notified of a media quality change we need to emit a
+   * MediaQualityChange event to the app.
+   *
+   * @param {shaka.extern.MediaQualityInfo} mediaQuality
+   * @param {number} position
+   *
+   * @private
+   */
+  onMediaQualityChange_(mediaQuality, position) {
+    // Always make a copy to avoid exposing our internal data to the app.
+    const clone = {
+      bandwidth: mediaQuality.bandwidth,
+      audioSamplingRate: mediaQuality.audioSamplingRate,
+      codecs: mediaQuality.codecs,
+      contentType: mediaQuality.contentType,
+      frameRate: mediaQuality.frameRate,
+      height: mediaQuality.height,
+      mimeType: mediaQuality.mimeType,
+      channelsCount: mediaQuality.channelsCount,
+      pixelAspectRatio: mediaQuality.pixelAspectRatio,
+      width: mediaQuality.width,
+    };
+
+    const data = new Map()
+        .set('mediaQuality', clone)
+        .set('position', position);
+
+    this.dispatchEvent(this.makeEvent_(
+        shaka.Player.EventName.MediaQualityChanged, data));
+  }
+
   /**
    * Turn the media element's error object into a Shaka Player error object.
    *
@@ -6268,6 +6464,8 @@ shaka.Player.EventName = {
   AbrStatusChanged: 'abrstatuschanged',
   Adaptation: 'adaptation',
   Buffering: 'buffering',
+  DownloadFailed: 'downloadfailed',
+  DownloadHeadersReceived: 'downloadheadersreceived',
   DrmSessionUpdate: 'drmsessionupdate',
   Emsg: 'emsg',
   Error: 'error',
@@ -6276,6 +6474,7 @@ shaka.Player.EventName = {
   Loaded: 'loaded',
   Loading: 'loading',
   ManifestParsed: 'manifestparsed',
+  MediaQualityChanged: 'mediaqualitychanged',
   Metadata: 'metadata',
   OnStateChange: 'onstatechange',
   OnStateIdle: 'onstateidle',
@@ -6331,7 +6530,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v3.2.2-uncompiled';
+shaka.Player.version = 'v3.3.0-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/random_uuid.js

@@ -0,0 +1,52 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+goog.provide('shaka.polyfill.RandomUUID');
+
+goog.require('shaka.log');
+goog.require('shaka.polyfill');
+
+/**
+ * @summary A polyfill to provide window.crypto.randomUUID in all browsers.
+ * @export
+ */
+shaka.polyfill.RandomUUID = class {
+  /**
+   * Install the polyfill if needed.
+   * @export
+   */
+  static install() {
+    shaka.log.debug('randomUUID.install');
+
+    if (!window.crypto) {
+      // See: https://caniuse.com/cryptography
+      shaka.log.debug(
+          'window.crypto must be available to install randomUUID polyfill.');
+      return;
+    }
+
+    if ('randomUUID' in window.crypto) {
+      shaka.log.debug(
+          'RandomUUID: Native window.crypto.randomUUID() support found.');
+      return;
+    }
+
+    window.crypto.randomUUID = shaka.polyfill.RandomUUID.randomUUID_;
+  }
+
+  /**
+   * @return {string}
+   * @private
+   */
+  static randomUUID_() {
+    const url = URL.createObjectURL(new Blob());
+    const uuid = url.toString();
+    URL.revokeObjectURL(url);
+    return uuid.substr(uuid.lastIndexOf('/') + 1);
+  }
+};
+
+
+shaka.polyfill.register(shaka.polyfill.RandomUUID.install);

package/lib/text/cue.js

@@ -144,6 +144,18 @@ shaka.text.Cue = class {
      */
     this.border = '';
 
+    /**
+     * @override
+     * @exportInterface
+     */
+    this.textStrokeColor = '';
+
+    /**
+     * @override
+     * @exportInterface
+     */
+    this.textStrokeWidth = '';
+
     /**
      * @override
      * @exportInterface

package/lib/text/ttml_text_parser.js

@@ -531,7 +531,6 @@ shaka.text.TtmlTextParser = class {
 
     const color = TtmlTextParser.getStyleAttribute_(
         cueElement, region, styles, 'color', shouldInheritRegionStyles);
-
     if (color) {
       cue.color = color;
     }
@@ -584,7 +583,6 @@ shaka.text.TtmlTextParser = class {
 
     const fontSize = TtmlTextParser.getStyleAttribute_(
         cueElement, region, styles, 'fontSize', shouldInheritRegionStyles);
-
     if (fontSize) {
       const isValidFontSizeUnit =
           fontSize.match(TtmlTextParser.unitValues_) ||
@@ -622,6 +620,31 @@ shaka.text.TtmlTextParser = class {
       }
     }
 
+    const textOutline = TtmlTextParser.getStyleAttribute_(
+        cueElement, region, styles, 'textOutline', shouldInheritRegionStyles);
+    if (textOutline) {
+      // tts:textOutline isn't natively supported by browsers, but it can be
+      // mostly replicated using the non-standard -webkit-text-stroke-width and
+      // -webkit-text-stroke-color properties.
+      const split = textOutline.split(' ');
+      if (split[0].match(TtmlTextParser.unitValues_)) {
+        // There is no defined color, so default to the text color.
+        cue.textStrokeColor = cue.color;
+      } else {
+        cue.textStrokeColor = split[0];
+        split.shift();
+      }
+      if (split[0] && split[0].match(TtmlTextParser.unitValues_)) {
+        cue.textStrokeWidth = split[0];
+      } else {
+        // If there is no width, or the width is not a number, don't draw a
+        // border.
+        cue.textStrokeColor = '';
+      }
+      // There is an optional blur radius also, but we have no way of
+      // replicating that, so ignore it.
+    }
+
     const letterSpacing = TtmlTextParser.getStyleAttribute_(
         cueElement, region, styles, 'letterSpacing', shouldInheritRegionStyles);
     if (letterSpacing && letterSpacing.match(TtmlTextParser.unitValues_)) {

package/lib/text/ui_text_displayer.js

@@ -403,8 +403,8 @@ shaka.text.UITextDisplayer = class {
       return nonBreakingSpace.repeat(match.length);
     });
 
-    style.backgroundColor = cue.backgroundColor;
-    style.border = cue.border;
+    style.webkitTextStrokeColor = cue.textStrokeColor;
+    style.webkitTextStrokeWidth = cue.textStrokeWidth;
     style.color = cue.color;
     style.direction = cue.direction;
     style.opacity = cue.opacity;