shaka-player 3.2.2 → 3.3.0

package/externs/shaka/player.js

@@ -468,6 +468,48 @@ shaka.extern.ID3Metadata;
  */
 shaka.extern.TimelineRegionInfo;
 
+/**
+ * @typedef {{
+ *   audioSamplingRate: ?number,
+ *   bandwidth: number,
+ *   codecs: string,
+ *   contentType: string,
+ *   frameRate: ?number,
+ *   height: ?number,
+ *   mimeType: ?string,
+ *   channelsCount: ?number,
+ *   pixelAspectRatio: ?string,
+ *   width: ?number
+ * }}
+ *
+ * @description
+ * Contains information about the quality of an audio or video media stream.
+ *
+ * @property {?number} audioSamplingRate
+ *   Specifies the maximum sampling rate of the content.
+ * @property {number} bandwidth
+ *   The bandwidth in bits per second.
+ * @property {string} codecs
+ *   The Stream's codecs, e.g., 'avc1.4d4015' or 'vp9', which must be
+ * compatible with the Stream's MIME type.
+ * @property {string} contentType
+ *   The type of content, which may be "video" or "audio".
+ * @property {?number} frameRate
+ *   The video frame rate.
+ * @property {?number} height
+ *   The video height in pixels.
+ * @property {string} mimeType
+ *   The MIME type.
+ * @property {?number} channelsCount
+ *   The number of audio channels, or null if unknown.
+ * @property {?string} pixelAspectRatio
+ *   The pixel aspect ratio value; e.g "1:1".
+ * @property {?number} width
+ *   The video width in pixels.
+ * @exportDoc
+ */
+shaka.extern.MediaQualityInfo;
+
 
 /**
  * @typedef {{
@@ -698,7 +740,9 @@ shaka.extern.DashManifestConfiguration;
  * @typedef {{
  *   ignoreTextStreamFailures: boolean,
  *   ignoreImageStreamFailures: boolean,
- *   useFullSegmentsForStartTime: boolean
+ *   useFullSegmentsForStartTime: boolean,
+ *   defaultAudioCodec: string,
+ *   defaultVideoCodec: string
  * }}
  *
  * @property {boolean} ignoreTextStreamFailures
@@ -710,6 +754,12 @@ shaka.extern.DashManifestConfiguration;
  * @property {boolean} useFullSegmentsForStartTime
  *   If <code>true</code>, force HlsParser to use a full segment request for
  *   determining start time in case the server does not support partial requests
+ * @property {string} defaultAudioCodec
+ *   The default audio codec if it is not specified in the HLS playlist.
+ *   <i>Defaults to <code>'mp4a.40.2'</code>.</i>
+ * @property {string} defaultVideoCodec
+ *   The default video codec if it is not specified in the HLS playlist.
+ *   <i>Defaults to <code>'avc1.42E01E'</code>.</i>
  * @exportDoc
  */
 shaka.extern.HlsManifestConfiguration;
@@ -790,7 +840,9 @@ shaka.extern.ManifestConfiguration;
  *   autoLowLatencyMode: boolean,
  *   forceHTTPS: boolean,
  *   preferNativeHls: boolean,
- *   updateIntervalSeconds: number
+ *   updateIntervalSeconds: number,
+ *   dispatchAllEmsgBoxes: boolean,
+ *   observeQualityChanges: boolean
  * }}
  *
  * @description
@@ -899,7 +951,11 @@ shaka.extern.ManifestConfiguration;
  *   If true, prefer native HLS playback when possible, regardless of platform.
  * @property {number} updateIntervalSeconds
  *   The minimum number of seconds to see if the manifest has changes.
- *
+ * @property {boolean} dispatchAllEmsgBoxes
+ *   If true, all emsg boxes are parsed and dispatched.
+ * @property {boolean} observeQualityChanges
+ *   If true, monitor media quality changes and emit
+ *   <code.shaka.Player.MediaQualityChangedEvent</code>.
  * @exportDoc
  */
 shaka.extern.StreamingConfiguration;
@@ -913,7 +969,8 @@ shaka.extern.StreamingConfiguration;
  *   restrictions: shaka.extern.Restrictions,
  *   switchInterval: number,
  *   bandwidthUpgradeTarget: number,
- *   bandwidthDowngradeTarget: number
+ *   bandwidthDowngradeTarget: number,
+ *   advanced: shaka.extern.AdvancedAbrConfiguration
  * }}
  *
  * @property {boolean} enabled
@@ -930,7 +987,7 @@ shaka.extern.StreamingConfiguration;
  *   automatically, but will still appear in the track list and can still be
  *   selected via <code>selectVariantTrack()</code>.  If no tracks meet these
  *   restrictions, AbrManager should not fail, but choose a low-res or
- *   low-bandwidth variant instead.  It is the responsibiliy of AbrManager
+ *   low-bandwidth variant instead.  It is the responsibility of AbrManager
  *   implementations to follow these rules and implement this behavior.
  * @property {number} switchInterval
  *   The minimum amount of time that must pass between switches, in
@@ -941,11 +998,76 @@ shaka.extern.StreamingConfiguration;
  * @property {number} bandwidthDowngradeTarget
  *   The largest fraction of the estimated bandwidth we should use. We should
  *   downgrade to avoid this.
+ * @property {shaka.extern.AdvancedAbrConfiguration} advanced
+ *   Advanced ABR configuration.
  * @exportDoc
  */
 shaka.extern.AbrConfiguration;
 
 
+/**
+ * @typedef {{
+ *   minTotalBytes: number,
+ *   minBytes: number,
+ *   fastHalfLife: number,
+ *   slowHalfLife: number
+ * }}
+ *
+ * @property {number} minTotalBytes
+ *   Minimum number of bytes sampled before we trust the estimate.  If we have
+ *   not sampled much data, our estimate may not be accurate enough to trust.
+ * @property {number} minBytes
+ *   Minimum number of bytes, under which samples are discarded.  Our models
+ *   do not include latency information, so connection startup time (time to
+ *   first byte) is considered part of the download time.  Because of this, we
+ *   should ignore very small downloads which would cause our estimate to be
+ *   too low.
+ * @property {number} fastHalfLife
+ *   The quantity of prior samples (by weight) used when creating a new
+ *   estimate, in seconds.  Those prior samples make up half of the
+ *   new estimate.
+ * @property {number} slowHalfLife
+ *   The quantity of prior samples (by weight) used when creating a new
+ *   estimate, in seconds.  Those prior samples make up half of the
+ *   new estimate.
+ * @exportDoc
+ */
+shaka.extern.AdvancedAbrConfiguration;
+
+
+/**
+ * @typedef {{
+ *   enabled: boolean,
+ *   useHeaders: boolean,
+ *   sessionId: string,
+ *   contentId: string
+ * }}
+ *
+ * @description
+ *   Common Media Client Data (CMCD) configuration.
+ *
+ * @property {boolean} enabled
+ *   If <code>true</code>, enable CMCD data to be sent with media requests.
+ *   Defaults to <code>false</code>.
+ * @property {boolean} useHeaders
+ *   If <code>true</code>, send CMCD data using the header transmission mode
+ *   instead of query args.  Defaults to <code>false</code>.
+ * @property {string} sessionId
+ *   A GUID identifying the current playback session. A playback session
+ *   typically ties together segments belonging to a single media asset.
+ *   Maximum length is 64 characters. It is RECOMMENDED to conform to the UUID
+ *   specification. By default the sessionId is automatically generated on each
+ *   <code>load()</code> call.
+ * @property {string} contentId
+ *   A unique string identifying the current content. Maximum length is 64
+ *   characters. This value is consistent across multiple different sessions and
+ *   devices and is defined and updated at the discretion of the service
+ *   provider.
+ * @exportDoc
+ */
+shaka.extern.CmcdConfiguration;
+
+
 /**
  * @typedef {{
  *   trackSelectionCallback:
@@ -987,6 +1109,7 @@ shaka.extern.OfflineConfiguration;
  *   streaming: shaka.extern.StreamingConfiguration,
  *   abrFactory: shaka.extern.AbrManager.Factory,
  *   abr: shaka.extern.AbrConfiguration,
+ *   cmcd: shaka.extern.CmcdConfiguration,
  *   offline: shaka.extern.OfflineConfiguration,
  *   preferredAudioLanguage: string,
  *   preferredTextLanguage: string,
@@ -1013,6 +1136,8 @@ shaka.extern.OfflineConfiguration;
  *   A factory to construct an abr manager.
  * @property {shaka.extern.AbrConfiguration} abr
  *   ABR configuration and settings.
+ * @property {shaka.extern.CmcdConfiguration} cmcd
+ *   CMCD configuration and settings. (Common Media Client Data)
  * @property {shaka.extern.OfflineConfiguration} offline
  *   Offline configuration and settings.
  * @property {string} preferredAudioLanguage

package/externs/shaka/text.js

@@ -297,6 +297,20 @@ shaka.extern.Cue = class {
      */
     this.fontFamily;
 
+    /**
+     * Text stroke color as a CSS color, e.g. "#FFFFFF" or "white".
+     * @type {string}
+     * @exportDoc
+     */
+    this.textStrokeColor;
+
+    /**
+     * Text stroke width as a CSS stroke-width value.
+     * @type {string}
+     * @exportDoc
+     */
+    this.textStrokeWidth;
+
     /**
      * Text letter spacing as a CSS letter-spacing value.
      * @type {string}

package/externs/webcrypto.js

@@ -0,0 +1,18 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+
+/**
+ * @fileoverview Externs for crypto properties not in the Closure compiler.
+ *
+ * @externs
+ */
+
+
+/**
+ * @return {string}
+ */
+webCrypto.Crypto.prototype.randomUUID = function() {};

package/lib/abr/ewma.js

@@ -35,6 +35,20 @@ shaka.abr.Ewma = class {
     this.totalWeight_ = 0;
   }
 
+
+  /**
+   * Update the alpha with a new halfLife value.
+   *
+   * @param {number} halfLife The quantity of prior samples (by weight) used
+   *   when creating a new estimate.  Those prior samples make up half of the
+   *   new estimate.
+   */
+  updateAlpha(halfLife) {
+    goog.asserts.assert(halfLife > 0, 'expected halfLife to be positive');
+    this.alpha_ = Math.exp(Math.log(0.5) / halfLife);
+  }
+
+
   /**
    * Takes a sample.
    *

package/lib/abr/ewma_bandwidth_estimator.js

@@ -47,7 +47,6 @@ shaka.abr.EwmaBandwidthEstimator = class {
      * This specific value is based on experimentation.
      *
      * @private {number}
-     * @const
      */
     this.minTotalBytes_ = 128e3;  // 128kB
 
@@ -60,11 +59,26 @@ shaka.abr.EwmaBandwidthEstimator = class {
      * This specific value is based on experimentation.
      *
      * @private {number}
-     * @const
      */
     this.minBytes_ = 16e3;  // 16kB
   }
 
+
+  /**
+   * Called by the Player to provide an updated configuration any time it
+   * changes.
+   * Must be called at least once before init().
+   *
+   * @param {shaka.extern.AdvancedAbrConfiguration} config
+   */
+  configure(config) {
+    this.minTotalBytes_ = config.minTotalBytes;
+    this.minBytes_ = config.minBytes;
+    this.fast_.updateAlpha(config.fastHalfLife);
+    this.slow_.updateAlpha(config.slowHalfLife);
+  }
+
+
   /**
    * Takes a bandwidth sample.
    *

package/lib/abr/simple_abr_manager.js

@@ -54,6 +54,9 @@ shaka.abr.SimpleAbrManager = class {
       navigator.connection.addEventListener('change', () => {
         if (this.config_.useNetworkInformation && this.enabled_) {
           this.bandwidthEstimator_ = new shaka.abr.EwmaBandwidthEstimator();
+          if (this.config_) {
+            this.bandwidthEstimator_.configure(this.config_.advanced);
+          }
           const chosenVariant = this.chooseVariant();
           if (chosenVariant) {
             this.switch_(chosenVariant);
@@ -239,6 +242,9 @@ shaka.abr.SimpleAbrManager = class {
    */
   configure(config) {
     this.config_ = config;
+    if (this.bandwidthEstimator_ && this.config_) {
+      this.bandwidthEstimator_.configure(this.config_.advanced);
+    }
   }
 
 

package/lib/ads/client_side_ad.js

@@ -162,6 +162,14 @@ shaka.ads.ClientSideAd = class {
     return this.manager_.getVolume() == 0;
   }
 
+  /**
+   * @override
+   * @export
+   */
+  isLinear() {
+    return this.ad_.isLinear();
+  }
+
 
   /**
    * @override

package/lib/ads/client_side_ad_manager.js

@@ -396,8 +396,10 @@ shaka.ads.ClientSideAdManager = class {
         .set('originalEvent', e);
     this.onEvent_(new shaka.util.FakeEvent(
         shaka.ads.AdManager.AD_STARTED, data));
-    this.adContainer_.setAttribute('ad-active', 'true');
-    this.video_.pause();
+    if (this.ad_.isLinear()) {
+      this.adContainer_.setAttribute('ad-active', 'true');
+      this.video_.pause();
+    }
   }
 
   /**
@@ -407,7 +409,9 @@ shaka.ads.ClientSideAdManager = class {
   onAdComplete_(e) {
     this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STOPPED,
         (new Map()).set('originalEvent', e)));
-    this.adContainer_.removeAttribute('ad-active');
-    this.video_.play();
+    if (this.ad_.isLinear()) {
+      this.adContainer_.removeAttribute('ad-active');
+      this.video_.play();
+    }
   }
 };

package/lib/ads/server_side_ad.js

@@ -152,6 +152,13 @@ shaka.ads.ServerSideAd = class {
     return this.video_.muted;
   }
 
+  /**
+   * @override
+   * @export
+   */
+  isLinear() {
+    return true;
+  }
 
   /**
    * @override

package/lib/cast/cast_utils.js

@@ -388,6 +388,7 @@ shaka.cast.CastUtils.PlayerVoidMethods = [
   'selectVariantsByLabel',
   'setTextTrackVisibility',
   'trickPlay',
+  'updateStartTime',
   'goToLive',
 ];
 

package/lib/dash/dash_parser.js

@@ -19,6 +19,7 @@ goog.require('shaka.media.PresentationTimeline');
 goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.text.TextEngine');
+goog.require('shaka.util.CmcdManager');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.Functional');
 goog.require('shaka.util.Iterables');
@@ -58,12 +59,12 @@ shaka.dash.DashParser = class {
     this.globalId_ = 1;
 
     /**
-     * A map of IDs to SegmentIndex objects.
+     * A map of IDs to Stream objects.
      * ID: Period@id,AdaptationSet@id,@Representation@id
      * e.g.: '1,5,23'
-     * @private {!Object.<string, !shaka.media.SegmentIndex>}
+     * @private {!Object.<string, !shaka.extern.Stream>}
      */
-    this.segmentIndexMap_ = {};
+    this.streamMap_ = {};
 
     /**
      * A map of period ids to their durations
@@ -164,8 +165,10 @@ shaka.dash.DashParser = class {
   stop() {
     // When the parser stops, release all segment indexes, which stops their
     // timers, as well.
-    for (const segmentIndex of Object.values(this.segmentIndexMap_)) {
-      segmentIndex.release();
+    for (const stream of Object.values(this.streamMap_)) {
+      if (stream.segmentIndex) {
+        stream.segmentIndex.release();
+      }
     }
 
     if (this.periodCombiner_) {
@@ -176,7 +179,7 @@ shaka.dash.DashParser = class {
     this.config_ = null;
     this.manifestUris_ = [];
     this.manifest_ = null;
-    this.segmentIndexMap_ = {};
+    this.streamMap_ = {};
     this.periodCombiner_ = null;
 
     if (this.updateTimer_ != null) {
@@ -224,6 +227,9 @@ shaka.dash.DashParser = class {
         this.manifestUris_, this.config_.retryParameters);
     const networkingEngine = this.playerInterface_.networkingEngine;
 
+    const format = shaka.util.CmcdManager.StreamingFormat.DASH;
+    this.playerInterface_.modifyManifestRequest(request, {format: format});
+
     const startTime = Date.now();
     const operation = networkingEngine.request(requestType, request);
     this.operationManager_.manage(operation);
@@ -378,8 +384,11 @@ shaka.dash.DashParser = class {
       // that the complex logic of multi-Period eviction and period-flattening
       // is correct.  See also:
       // https://github.com/google/shaka-player/issues/3169#issuecomment-823580634
-      for (const segmentIndex of Object.values(this.segmentIndexMap_)) {
-        segmentIndex.evict(presentationTimeline.getSegmentAvailabilityStart());
+      for (const stream of Object.values(this.streamMap_)) {
+        if (stream.segmentIndex) {
+          stream.segmentIndex.evict(
+              presentationTimeline.getSegmentAvailabilityStart());
+        }
       }
     } else {
       // DASH IOP v3.0 suggests using a default delay between minBufferTime
@@ -1163,11 +1172,12 @@ shaka.dash.DashParser = class {
             context, requestInitSegment);
       } else if (context.representation.segmentList) {
         streamInfo = shaka.dash.SegmentList.createStreamInfo(
-            context, this.segmentIndexMap_);
+            context, this.streamMap_);
       } else if (context.representation.segmentTemplate) {
         const hasManifest = !!this.manifest_;
+
         streamInfo = shaka.dash.SegmentTemplate.createStreamInfo(
-            context, requestInitSegment, this.segmentIndexMap_, hasManifest,
+            context, requestInitSegment, this.streamMap_, hasManifest,
             this.config_.dash.initialSegmentLimit, this.periodDurations_);
       } else {
         goog.asserts.assert(isText,
@@ -1220,8 +1230,10 @@ shaka.dash.DashParser = class {
 
     let forced = false;
     if (isText) {
-      // See: https://github.com/google/shaka-player/issues/2122
-      forced = roles.includes('forced_subtitle');
+      // See: https://github.com/google/shaka-player/issues/2122 and
+      // https://github.com/Dash-Industry-Forum/DASH-IF-IOP/issues/165
+      forced = roles.includes('forced_subtitle') ||
+          roles.includes('forced-subtitle');
     }
 
     let tilesLayout;
@@ -1254,13 +1266,29 @@ shaka.dash.DashParser = class {
       hdr = 'PQ';
     }
 
+    const contextId = context.representation.id ?
+        context.period.id + ',' + context.representation.id : '';
+
     /** @type {shaka.extern.Stream} */
     const stream = {
       id: this.globalId_++,
       originalId: context.representation.id,
       createSegmentIndex: async () => {
-        if (!stream.segmentIndex) {
-          stream.segmentIndex = await streamInfo.generateSegmentIndex();
+        // If we have a stream with the same context id stored in the map
+        // that has no segmentIndex, we should set the segmentIndex for it.
+        const storedInMap = contextId && context.dynamic &&
+              this.streamMap_[contextId];
+
+        const currentStream = storedInMap ? this.streamMap_[contextId] : stream;
+        if (!currentStream.segmentIndex) {
+          currentStream.segmentIndex = await streamInfo.generateSegmentIndex();
+        }
+      },
+
+      closeSegmentIndex: () => {
+        if (stream.segmentIndex) {
+          stream.segmentIndex.release();
+          stream.segmentIndex = null;
         }
       },
       segmentIndex: null,
@@ -1290,7 +1318,13 @@ shaka.dash.DashParser = class {
       closedCaptions,
       hdr,
       tilesLayout,
+      matchedStreams: [],
     };
+
+    if (contextId && context.dynamic && !this.streamMap_[contextId]) {
+      this.streamMap_[contextId] = stream;
+    }
+
     return stream;
   }
 

package/lib/dash/segment_base.js

@@ -61,7 +61,9 @@ shaka.dash.SegmentBase = class {
     }
 
     const getUris = () => resolvedUris;
-    return new shaka.media.InitSegmentReference(getUris, startByte, endByte);
+    const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
+    return new shaka.media.InitSegmentReference(
+        getUris, startByte, endByte, qualityInfo);
   }
 
   /**
@@ -346,4 +348,26 @@ shaka.dash.SegmentBase = class {
         indexRange.start, indexRange.end,
         scaledPresentationTimeOffset);
   }
+
+  /**
+   * Create a MediaQualityInfo object from a Context object.
+   *
+   * @param {!shaka.dash.DashParser.Context} context
+   * @return {!shaka.extern.MediaQualityInfo}
+   */
+  static createQualityInfo(context) {
+    const representation = context.representation;
+    return {
+      bandwidth: context.bandwidth,
+      audioSamplingRate: representation.audioSamplingRate,
+      codecs: representation.codecs,
+      contentType: representation.contentType,
+      frameRate: representation.frameRate || null,
+      height: representation.height || null,
+      mimeType: representation.mimeType,
+      channelsCount: representation.numChannels,
+      pixelAspectRatio: representation.pixelAspectRatio || null,
+      width: representation.width || null,
+    };
+  }
 };

package/lib/dash/segment_list.js

@@ -30,10 +30,10 @@ shaka.dash.SegmentList = class {
    * Updates the existing SegmentIndex, if any.
    *
    * @param {shaka.dash.DashParser.Context} context
-   * @param {!Object.<string, !shaka.media.SegmentIndex>} segmentIndexMap
+   * @param {!Object.<string, !shaka.extern.Stream>} streamMap
    * @return {shaka.dash.DashParser.StreamInfo}
    */
-  static createStreamInfo(context, segmentIndexMap) {
+  static createStreamInfo(context, streamMap) {
     goog.asserts.assert(context.representation.segmentList,
         'Should only be called with SegmentList');
     const SegmentList = shaka.dash.SegmentList;
@@ -46,11 +46,14 @@ shaka.dash.SegmentList = class {
 
     /** @type {shaka.media.SegmentIndex} */
     let segmentIndex = null;
-    let id = null;
+    let stream = null;
     if (context.period.id && context.representation.id) {
       // Only check/store the index if period and representation IDs are set.
-      id = context.period.id + ',' + context.representation.id;
-      segmentIndex = segmentIndexMap[id];
+      const id = context.period.id + ',' + context.representation.id;
+      stream = streamMap[id];
+      if (stream) {
+        segmentIndex = stream.segmentIndex;
+      }
     }
 
     const references = SegmentList.createSegmentReferences_(
@@ -64,9 +67,6 @@ shaka.dash.SegmentList = class {
       segmentIndex.mergeAndEvict(references, start);
     } else {
       segmentIndex = new shaka.media.SegmentIndex(references);
-      if (id && context.dynamic) {
-        segmentIndexMap[id] = segmentIndex;
-      }
     }
     context.presentationTimeline.notifySegments(references);
 
@@ -77,8 +77,17 @@ shaka.dash.SegmentList = class {
       segmentIndex.fit(periodStart, periodEnd, isNew);
     }
 
+    if (stream) {
+      stream.segmentIndex = segmentIndex;
+    }
+
     return {
-      generateSegmentIndex: () => Promise.resolve(segmentIndex),
+      generateSegmentIndex: () => {
+        if (!segmentIndex || segmentIndex.isEmpty()) {
+          segmentIndex.merge(references);
+        }
+        return Promise.resolve(segmentIndex);
+      },
     };
   }