shaka-player 4.3.9 → 4.4.0

package/lib/util/cmcd_manager.js

@@ -8,7 +8,7 @@ goog.provide('shaka.util.CmcdManager');
 
 goog.require('goog.Uri');
 goog.require('shaka.log');
-
+goog.require('shaka.net.NetworkingEngine');
 
 /**
  * @summary
@@ -57,6 +57,16 @@ shaka.util.CmcdManager = class {
     this.starved_ = false;
   }
 
+  /**
+   * Called by the Player to provide an updated configuration any time it
+   * changes.
+   *
+   * @param {shaka.extern.CmcdConfiguration} config
+   */
+  configure(config) {
+    this.config_ = config;
+  }
+
   /**
    * Set the buffering state
    *
@@ -74,21 +84,67 @@ shaka.util.CmcdManager = class {
     this.buffering_ = buffering;
   }
 
+  /**
+   * Apply CMCD data to a request.
+   *
+   * @param {!shaka.net.NetworkingEngine.RequestType} type
+   *   The request type
+   * @param {!shaka.extern.Request} request
+   *   The request to apply CMCD data to
+   * @param {shaka.extern.RequestContext=} context
+   *   The request context
+   */
+  applyData(type, request, context = {}) {
+    if (!this.config_.enabled) {
+      return;
+    }
+
+    if (request.method === 'HEAD') {
+      this.apply_(request);
+      return;
+    }
+
+    const RequestType = shaka.net.NetworkingEngine.RequestType;
+    const ObjectType = shaka.util.CmcdManager.ObjectType;
+
+    switch (type) {
+      case RequestType.MANIFEST:
+        this.applyManifestData(request, context);
+        break;
+
+      case RequestType.SEGMENT:
+        this.applySegmentData(request, context);
+        break;
+
+      case RequestType.LICENSE:
+      case RequestType.SERVER_CERTIFICATE:
+      case RequestType.KEY:
+        this.apply_(request, {ot: ObjectType.KEY});
+        break;
+
+      case RequestType.TIMING:
+        this.apply_(request, {ot: ObjectType.OTHER});
+        break;
+    }
+  }
+
   /**
    * Apply CMCD data to a manifest request.
    *
    * @param {!shaka.extern.Request} request
    *   The request to apply CMCD data to
-   * @param {shaka.util.CmcdManager.ManifestInfo} manifestInfo
-   *   The manifest format
+   * @param {shaka.extern.RequestContext} context
+   *   The request context
    */
-  applyManifestData(request, manifestInfo) {
+  applyManifestData(request, context) {
     try {
       if (!this.config_.enabled) {
         return;
       }
 
-      this.sf_ = manifestInfo.format;
+      if (context.type) {
+        this.sf_ = this.getStreamFormat_(context.type);
+      }
 
       this.apply_(request, {
         ot: shaka.util.CmcdManager.ObjectType.MANIFEST,
@@ -104,33 +160,44 @@ shaka.util.CmcdManager = class {
    * Apply CMCD data to a segment request
    *
    * @param {!shaka.extern.Request} request
-   * @param {shaka.util.CmcdManager.SegmentInfo} segmentInfo
+   * @param {shaka.extern.RequestContext} context
+   *   The request context
    */
-  applySegmentData(request, segmentInfo) {
+  applySegmentData(request, context) {
     try {
       if (!this.config_.enabled) {
         return;
       }
 
+      const segment = context.segment;
+
+      let duration = 0;
+      if (segment) {
+        duration = segment.endTime - segment.startTime;
+      }
+
       const data = {
-        d: segmentInfo.duration * 1000,
+        d: duration * 1000,
         st: this.getStreamType_(),
       };
 
-      data.ot = this.getObjectType_(segmentInfo);
+      data.ot = this.getObjectType_(context);
 
       const ObjectType = shaka.util.CmcdManager.ObjectType;
       const isMedia = data.ot === ObjectType.VIDEO ||
-                      data.ot === ObjectType.AUDIO ||
-                      data.ot === ObjectType.MUXED ||
-                      data.ot === ObjectType.TIMED_TEXT;
-
-      if (isMedia) {
-        data.bl = this.getBufferLength_(segmentInfo.type);
-      }
-
-      if (segmentInfo.bandwidth) {
-        data.br = segmentInfo.bandwidth / 1000;
+          data.ot === ObjectType.AUDIO ||
+          data.ot === ObjectType.MUXED ||
+          data.ot === ObjectType.TIMED_TEXT;
+
+      const stream = context.stream;
+      if (stream) {
+        if (isMedia) {
+          data.bl = this.getBufferLength_(stream.type);
+        }
+
+        if (stream.bandwidth) {
+          data.br = stream.bandwidth / 1000;
+        }
       }
 
       if (isMedia && data.ot !== ObjectType.TIMED_TEXT) {
@@ -256,7 +323,7 @@ shaka.util.CmcdManager = class {
     data.pr = this.playerInterface_.getPlaybackRate();
 
     const isVideo = data.ot === shaka.util.CmcdManager.ObjectType.VIDEO ||
-      data.ot === shaka.util.CmcdManager.ObjectType.MUXED;
+        data.ot === shaka.util.CmcdManager.ObjectType.MUXED;
 
     if (this.starved_ && isVideo) {
       data.bs = true;
@@ -292,18 +359,26 @@ shaka.util.CmcdManager = class {
   /**
    * The CMCD object type.
    *
-   * @param {shaka.util.CmcdManager.SegmentInfo} segmentInfo
+   * @param {shaka.extern.RequestContext} context
+   *   The request context
    * @private
    */
-  getObjectType_(segmentInfo) {
-    const type = segmentInfo.type;
-
-    if (segmentInfo.init) {
+  getObjectType_(context) {
+    if (context.type ===
+        shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT) {
       return shaka.util.CmcdManager.ObjectType.INIT;
     }
 
+    const stream = context.stream;
+
+    if (!stream) {
+      return undefined;
+    }
+
+    const type = stream.type;
+
     if (type == 'video') {
-      if (segmentInfo.codecs.includes(',')) {
+      if (stream.codecs && stream.codecs.includes(',')) {
         return shaka.util.CmcdManager.ObjectType.MUXED;
       }
       return shaka.util.CmcdManager.ObjectType.VIDEO;
@@ -314,7 +389,7 @@ shaka.util.CmcdManager = class {
     }
 
     if (type == 'text') {
-      if (segmentInfo.mimeType === 'application/mp4') {
+      if (stream.mimeType === 'application/mp4') {
         return shaka.util.CmcdManager.ObjectType.TIMED_TEXT;
       }
       return shaka.util.CmcdManager.ObjectType.CAPTION;
@@ -368,6 +443,32 @@ shaka.util.CmcdManager = class {
     return (range.end - start) * 1000;
   }
 
+  /**
+   * Get the stream format
+   *
+   * @param {shaka.net.NetworkingEngine.AdvancedRequestType} type
+   *   The request's advanced type
+   * @return {(shaka.util.CmcdManager.StreamingFormat|undefined)}
+   * @private
+   */
+  getStreamFormat_(type) {
+    const AdvancedRequestType = shaka.net.NetworkingEngine.AdvancedRequestType;
+
+    switch (type) {
+      case AdvancedRequestType.MPD:
+        return shaka.util.CmcdManager.StreamingFormat.DASH;
+
+      case AdvancedRequestType.MASTER_PLAYLIST:
+      case AdvancedRequestType.MEDIA_PLAYLIST:
+        return shaka.util.CmcdManager.StreamingFormat.HLS;
+
+      case AdvancedRequestType.MSS:
+        return shaka.util.CmcdManager.StreamingFormat.SMOOTH;
+    }
+
+    return undefined;
+  }
+
   /**
    * Get the stream type
    *
@@ -566,8 +667,8 @@ shaka.util.CmcdManager = class {
  *   getBandwidthEstimate: function():number,
  *   getBufferedInfo: function():shaka.extern.BufferedInfo,
  *   getCurrentTime: function():number,
- *   getVariantTracks: function():Array.<shaka.extern.Track>,
  *   getPlaybackRate: function():number,
+ *   getVariantTracks: function():Array.<shaka.extern.Track>,
  *   isLive: function():boolean
  * }}
  *
@@ -577,57 +678,16 @@ shaka.util.CmcdManager = class {
  *   Get information about what the player has buffered.
  * @property {function():number} getCurrentTime
  *   Get the current time
- * @property {function():Array.<shaka.extern.Track>} getVariantTracks
- *   Get the variant tracks
  * @property {function():number} getPlaybackRate
  *   Get the playback rate
+ * @property {function():Array.<shaka.extern.Track>} getVariantTracks
+ *   Get the variant tracks
  * @property {function():boolean} isLive
  *   Get if the player is playing live content.
  */
 shaka.util.CmcdManager.PlayerInterface;
 
 
-/**
- * @typedef {{
- *   type: string,
- *   init: boolean,
- *   duration: number,
- *   mimeType: string,
- *   codecs: string,
- *   bandwidth: (number|undefined)
- * }}
- *
- * @property {string} type
- *   The media type
- * @property {boolean} init
- *   Flag indicating whether the segment is an init segment
- * @property {number} duration
- *   The duration of the segment in seconds
- * @property {string} mimeType
- *   The segment's mime type
- * @property {string} codecs
- *   The segment's codecs
- * @property {(number|undefined)} bandwidth
- *   The segment's variation bandwidth
- *
- * @export
- */
-shaka.util.CmcdManager.SegmentInfo;
-
-
-/**
- * @typedef {{
- *   format: shaka.util.CmcdManager.StreamingFormat
- * }}
- *
- * @property {shaka.util.CmcdManager.StreamingFormat} format
- *   The manifest's stream format
- *
- * @export
- */
-shaka.util.CmcdManager.ManifestInfo;
-
-
 /**
  * @enum {string}
  */

package/lib/util/error.js

@@ -88,20 +88,19 @@ shaka.util.Error = class {
        */
       this.message = 'Shaka Error ' + categoryName + '.' + codeName +
                      ' (' + this.data.toString() + ')';
+    }
 
-      if (shaka.util.Error.createStack) {
-        try {
-          throw new Error(this.message);
-        } catch (e) {
-          /**
-           * A stack-trace showing where the error occurred.
-           * <i>(Only available in uncompiled mode.)</i>
-           *
-           * @const {string}
-           * @exportDoc
-           */
-          this.stack = e.stack;
-        }
+    if (shaka.util.Error.createStack) {
+      try {
+        throw new Error(this.message || 'Shaka Error');
+      } catch (e) {
+        /**
+         * A stack-trace showing where the error occurred.
+         *
+         * @const {string}
+         * @exportDoc
+         */
+        this.stack = e.stack;
       }
     }
   }
@@ -117,18 +116,15 @@ shaka.util.Error = class {
 };
 
 
-if (goog.DEBUG) {
-  /**
-   * If true, create a stack trace in Error objects.
-   *
-   * Only available in uncompiled mode, and disabled in tests to avoid issues
-   * with karma-jasmine.  See comments in test/test/boot.js for details.
-   *
-   * @type {boolean}
-   */
-  shaka.util.Error.createStack = true;
-}
-
+/**
+ * If true, create a stack trace in Error objects.
+ *
+ * Disabled in tests to avoid issues with karma-jasmine.
+ * See comments in test/test/boot.js for details.
+ *
+ * @type {boolean}
+ */
+shaka.util.Error.createStack = true;
 
 /**
  * @enum {number}
@@ -462,6 +458,7 @@ shaka.util.Error.Code = {
   /**
    * A MediaSource operation threw an exception.
    * <br> error.data[0] is the exception that was thrown.
+   * <br> error.data[1] is the error object from the video element.
    */
   'MEDIA_SOURCE_OPERATION_THREW': 3015,
 
@@ -496,6 +493,22 @@ shaka.util.Error.Code = {
    */
   'CONTENT_TRANSFORMATION_FAILED': 3019,
 
+  /**
+   * Important data is missing to be able to do the transmuxing of MSS.
+   */
+  'MSS_MISSING_DATA_FOR_TRANSMUXING': 3020,
+
+  /**
+   * MSS transmuing failed for unknown codec.
+   * <br> error.data[0] is a unknown codec.
+   */
+  'MSS_TRANSMUXING_CODEC_UNKNOWN': 3021,
+
+  /**
+   * MSS transmuing failed for unknown reason.
+   */
+  'MSS_TRANSMUXING_FAILED': 3022,
+
 
   /**
    * The Player was unable to guess the manifest type based on file extension
@@ -724,6 +737,17 @@ shaka.util.Error.Code = {
    */
   'CANNOT_ADD_EXTERNAL_THUMBNAILS_TO_LIVE_STREAM': 4045,
 
+  /**
+   * The MSS Manifest contained invalid XML markup.
+   * <br> error.data[0] is the URI associated with the XML.
+   */
+  'MSS_INVALID_XML': 4046,
+
+  /**
+   * MSS parser encountered a live playlist.
+   */
+  'MSS_LIVE_CONTENT_NOT_SUPPORTED': 4047,
+
 
   // RETIRED: 'INCONSISTENT_BUFFER_STATE': 5000,
   // RETIRED: 'INVALID_SEGMENT_INDEX': 5001,
@@ -830,7 +854,8 @@ shaka.util.Error.Code = {
   'NO_LICENSE_SERVER_GIVEN': 6012,
 
   /**
-   * A required offline session was removed.  The content is not playable.
+   * A required offline session was removed. The content might not be playable
+   * depending of the playback context.
    */
   'OFFLINE_SESSION_REMOVED': 6013,
 
@@ -858,6 +883,17 @@ shaka.util.Error.Code = {
    */
   'SERVER_CERTIFICATE_REQUEST_FAILED': 6017,
 
+  /**
+   * The HDCP version does not meet the requirements.
+   */
+  'MIN_HDCP_VERSION_NOT_MATCH': 6018,
+
+  /**
+   * Error when checking HDCP version.
+   * <br> error.data[0] is an error message string from the browser.
+   */
+  'ERROR_CHECKING_HDCP_VERSION': 6019,
+
 
   /**
    * The call to Player.load() was interrupted by a call to Player.unload()

package/lib/util/exp_golomb.js

@@ -0,0 +1,220 @@
+/**
+ * @license
+ * Copyright Brightcove, 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.util.ExpGolomb');
+
+goog.require('shaka.util.DataViewReader');
+
+
+/**
+ * @summary
+ * Parser for exponential Golomb codes, a variable-bitwidth number encoding
+ * scheme used by h264.
+ * Based on https://github.com/videojs/mux.js/blob/main/lib/utils/exp-golomb.js
+ *
+ * @export
+ */
+shaka.util.ExpGolomb = class {
+  /**
+   * @param {!Uint8Array} data
+   */
+  constructor(data) {
+    /** @private {!Uint8Array} */
+    this.data_ = data;
+
+    /** @private {number} */
+    this.workingBytesAvailable_ = data.byteLength;
+
+    // the current word being examined
+    /** @private {number} */
+    this.workingWord_ = 0;
+
+    // the number of bits left to examine in the current word
+    /** @private {number} */
+    this.workingBitsAvailable_ = 0;
+  }
+
+  /**
+   * Load the next word
+   *
+   * @private
+   */
+  loadWord_() {
+    const position = this.data_.byteLength - this.workingBytesAvailable_;
+    const bytes = new Uint8Array(4);
+    const availableBytes = Math.min(4, this.workingBytesAvailable_);
+
+    if (availableBytes === 0) {
+      return;
+    }
+
+    bytes.set(this.data_.subarray(position, position + availableBytes));
+    const dataView = new shaka.util.DataViewReader(
+        bytes, shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
+    this.workingWord_ = dataView.readUint32();
+
+    // track the amount of data that has been processed
+    this.workingBitsAvailable_ = availableBytes * 8;
+    this.workingBytesAvailable_ -= availableBytes;
+  }
+
+  /**
+   * Skip n bits
+   *
+   * @param {number} count
+   */
+  skipBits(count) {
+    if (this.workingBitsAvailable_ <= count) {
+      count -= this.workingBitsAvailable_;
+      const skipBytes = Math.floor(count / 8);
+      count -= (skipBytes * 8);
+      this.workingBitsAvailable_ -= skipBytes;
+      this.loadWord_();
+    }
+    this.workingWord_ <<= count;
+    this.workingBitsAvailable_ -= count;
+  }
+
+  /**
+   * Read n bits
+   *
+   * @param {number} size
+   * @return {number}
+   */
+  readBits(size) {
+    let bits = Math.min(this.workingBitsAvailable_, size);
+    const valu = this.workingWord_ >>> (32 - bits);
+    this.workingBitsAvailable_ -= bits;
+    if (this.workingBitsAvailable_ > 0) {
+      this.workingWord_ <<= bits;
+    } else if (this.workingBytesAvailable_ > 0) {
+      this.loadWord_();
+    }
+    bits = size - bits;
+    if (bits > 0) {
+      return (valu << bits) | this.readBits(bits);
+    }
+    return valu;
+  }
+
+  /**
+   * Return the number of skip leading zeros
+   *
+   * @return {number}
+   * @private
+   */
+  skipLeadingZeros_() {
+    let i;
+    for (i = 0; i < this.workingBitsAvailable_; ++i) {
+      if ((this.workingWord_ & (0x80000000 >>> i)) !== 0) {
+        // the first bit of working word is 1
+        this.workingWord_ <<= i;
+        this.workingBitsAvailable_ -= i;
+        return i;
+      }
+    }
+
+    // we exhausted workingWord and still have not found a 1
+    this.loadWord_();
+    return i + this.skipLeadingZeros_();
+  }
+
+  /**
+   * Skip exponential Golomb
+   */
+  skipExpGolomb() {
+    this.skipBits(1 + this.skipLeadingZeros_());
+  }
+
+  /**
+   * Return unsigned exponential Golomb
+   *
+   * @return {number}
+   */
+  readUnsignedExpGolomb() {
+    const clz = this.skipLeadingZeros_();
+    return this.readBits(clz + 1) - 1;
+  }
+
+  /**
+   * Return exponential Golomb
+   *
+   * @return {number}
+   */
+  readExpGolomb() {
+    const valu = this.readUnsignedExpGolomb();
+    if (0x01 & valu) {
+      // the number is odd if the low order bit is set
+      // add 1 to make it even, and divide by 2
+      return (1 + valu) >>> 1;
+    }
+    // divide by two then make it negative
+    return -1 * (valu >>> 1);
+  }
+
+  /**
+   * Read 1 bit as boolean
+   *
+   * @return {boolean}
+   */
+  readBoolean() {
+    return this.readBits(1) === 1;
+  }
+
+  /**
+   * Read 8 bits
+   *
+   * @return {number}
+   */
+  readUnsignedByte() {
+    return this.readBits(8);
+  }
+
+  /**
+   * The scaling list is optionally transmitted as part of a Sequence Parameter
+   * Set (SPS).
+   *
+   * @param {number} count the number of entries in this scaling list
+   * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
+   */
+  skipScalingList(count) {
+    let lastScale = 8;
+    let nextScale = 8;
+
+    for (let j = 0; j < count; j++) {
+      if (nextScale !== 0) {
+        const deltaScale = this.readExpGolomb();
+        nextScale = (lastScale + deltaScale + 256) % 256;
+      }
+      lastScale = (nextScale === 0) ? lastScale : nextScale;
+    }
+  }
+
+  /**
+   * Return the slice type
+   *
+   * @return {number}
+   */
+  readSliceType() {
+    // skip Nalu type
+    this.readUnsignedByte();
+    // discard first_mb_in_slice
+    this.readUnsignedExpGolomb();
+    // return slice_type
+    return this.readUnsignedExpGolomb();
+  }
+};