shaka-player 4.7.13 → 4.8.1

package/lib/util/dom_utils.js

@@ -53,6 +53,17 @@ shaka.util.Dom = class {
   }
 
 
+  /**
+   * Cast a Node/Element to an HTMLCanvasElement
+   *
+   * @param {!Node|!Element} original
+   * @return {!HTMLCanvasElement}
+   */
+  static asHTMLCanvasElement(original) {
+    return /** @type {!HTMLCanvasElement}*/ (original);
+  }
+
+
   /**
    * Cast a Node/Element to an HTMLMediaElement
    *

package/lib/util/error.js

@@ -946,6 +946,11 @@ shaka.util.Error.Code = {
    */
   'CONTENT_NOT_LOADED': 7004,
 
+  /**
+   * The call to preload failed, due to being called on src= content.
+   */
+  'SRC_EQUALS_PRELOAD_NOT_SUPPORTED': 7005,
+
   /**
    * The Cast API is unavailable.  This may be because of one of the following:
    *  1. The browser may not have Cast support

package/lib/util/fake_event.js

@@ -174,10 +174,12 @@ shaka.util.FakeEvent.EventName = {
   MediaQualityChanged: 'mediaqualitychanged',
   Metadata: 'metadata',
   Midpoint: 'midpoint',
+  NoSpatialVideoInfoEvent: 'nospatialvideoinfo',
   OnStateChange: 'onstatechange',
   RateChange: 'ratechange',
   SegmentAppended: 'segmentappended',
   SessionDataEvent: 'sessiondata',
+  SpatialVideoInfoEvent: 'spatialvideoinfo',
   StallDetected: 'stalldetected',
   Started: 'started',
   StateChanged: 'statechanged',

package/lib/util/manifest_parser_utils.js

@@ -7,7 +7,10 @@
 goog.provide('shaka.util.ManifestParserUtils');
 
 goog.require('goog.Uri');
+goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Error');
+goog.require('shaka.util.StringUtils');
+goog.require('shaka.util.Uint8ArrayUtils');
 
 
 /**
@@ -56,12 +59,14 @@ shaka.util.ManifestParserUtils = class {
    * Creates a DrmInfo object from the given info.
    *
    * @param {string} keySystem
+   * @param {string} encryptionScheme
    * @param {Array.<shaka.extern.InitDataOverride>} initData
    * @return {shaka.extern.DrmInfo}
    */
-  static createDrmInfo(keySystem, initData) {
+  static createDrmInfo(keySystem, encryptionScheme, initData) {
     return {
-      keySystem: keySystem,
+      keySystem,
+      encryptionScheme,
       licenseServerUri: '',
       distinctiveIdentifierRequired: false,
       persistentStateRequired: false,
@@ -75,6 +80,69 @@ shaka.util.ManifestParserUtils = class {
     };
   }
 
+  /**
+   * Creates a DrmInfo object from ClearKeys.
+   *
+   * @param {!Map.<string, string>} clearKeys
+   * @param {string=} encryptionScheme
+   * @return {shaka.extern.DrmInfo}
+   */
+  static createDrmInfoFromClearKeys(clearKeys, encryptionScheme = 'cenc') {
+    const StringUtils = shaka.util.StringUtils;
+    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
+    const keys = [];
+    const keyIds = [];
+    const originalKeyIds = [];
+
+    clearKeys.forEach((key, keyId) => {
+      let kid = keyId;
+      if (kid.length != 22) {
+        kid = Uint8ArrayUtils.toBase64(
+            Uint8ArrayUtils.fromHex(keyId), false);
+      }
+      let k = key;
+      if (k.length != 22) {
+        k = Uint8ArrayUtils.toBase64(
+            Uint8ArrayUtils.fromHex(key), false);
+      }
+      const keyObj = {
+        kty: 'oct',
+        kid: kid,
+        k: k,
+      };
+
+      keys.push(keyObj);
+      keyIds.push(keyObj.kid);
+      originalKeyIds.push(keyId);
+    });
+
+    const jwkSet = {keys: keys};
+    const license = JSON.stringify(jwkSet);
+
+    // Use the keyids init data since is suggested by EME.
+    // Suggestion: https://bit.ly/2JYcNTu
+    // Format: https://www.w3.org/TR/eme-initdata-keyids/
+    const initDataStr = JSON.stringify({'kids': keyIds});
+    const initData =
+        shaka.util.BufferUtils.toUint8(StringUtils.toUTF8(initDataStr));
+    const initDatas = [{initData: initData, initDataType: 'keyids'}];
+
+    return {
+      keySystem: 'org.w3.clearkey',
+      encryptionScheme,
+      licenseServerUri: 'data:application/json;base64,' + window.btoa(license),
+      distinctiveIdentifierRequired: false,
+      persistentStateRequired: false,
+      audioRobustness: '',
+      videoRobustness: '',
+      serverCertificate: null,
+      serverCertificateUri: '',
+      sessionType: '',
+      initData: initDatas,
+      keyIds: new Set(originalKeyIds),
+    };
+  }
+
 
   /**
    * Attempts to guess which codecs from the codecs list belong to a given
@@ -134,6 +202,30 @@ shaka.util.ManifestParserUtils = class {
 
     return null;
   }
+
+
+  /**
+   * Attempts to guess which codecs from the codecs list belong to a given
+   * content.
+   *
+   * @param {string} contentType
+   * @param {!Array.<string>} codecs
+   * @return {!Array.<string>}
+   */
+  static guessAllCodecsSafe(contentType, codecs) {
+    const allCodecs = [];
+    const formats = shaka.util.ManifestParserUtils
+        .CODEC_REGEXPS_BY_CONTENT_TYPE_[contentType];
+    for (const format of formats) {
+      for (const codec of codecs) {
+        if (format.test(codec.trim())) {
+          allCodecs.push(codec.trim());
+        }
+      }
+    }
+
+    return allCodecs;
+  }
 };
 
 
@@ -183,7 +275,9 @@ shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_ = [
   /^vvi/,
   /^vp0?[89]/,
   /^av01/,
-  /^dvh/,
+  /^dvh/, // Dolby Vision based in HEVC
+  /^dva/, // Dolby Vision based in AVC
+  /^dav/, // Dolby Vision based in AV1
 ];
 
 

package/lib/util/mp4_box_parsers.js

@@ -8,6 +8,7 @@ goog.provide('shaka.util.Mp4BoxParsers');
 
 goog.require('shaka.util.DataViewReader');
 goog.require('shaka.util.Mp4Parser');
+goog.require('shaka.util.Uint8ArrayUtils');
 
 shaka.util.Mp4BoxParsers = class {
   /**
@@ -329,7 +330,7 @@ shaka.util.Mp4BoxParsers = class {
       }
     }
     if (oti) {
-      codec += '.' + this.toHex_(oti);
+      codec += '.' + shaka.util.Mp4BoxParsers.toHex_(oti);
       if (tag == 0x05 && reader.hasMoreData()) {
         const firstData = reader.readUint8();
         let audioObjectType = (firstData & 0xF8) >> 3;
@@ -344,15 +345,146 @@ shaka.util.Mp4BoxParsers = class {
   }
 
   /**
-   * Parses a AVC box.
+   * Parses a AVCC box.
+   * @param {string} codecBase
    * @param {!shaka.util.DataViewReader} reader
    * @param {string} boxName
-   * @return {!shaka.util.ParsedAVCBox}
+   * @return {!shaka.util.ParsedAVCCBox}
    */
-  static parseAVC(reader, boxName) {
-    reader.skip(87);
-    const codec = boxName + '.' + this.toHex_(reader.readUint8()) +
-        this.toHex_(reader.readUint8()) + this.toHex_(reader.readUint8());
+  static parseAVCC(codecBase, reader, boxName) {
+    const Mp4BoxParsers = shaka.util.Mp4BoxParsers;
+    reader.skip(1); // Skip "configurationVersion"
+    const codec = codecBase + '.' +
+        Mp4BoxParsers.toHex_(reader.readUint8()) +
+        Mp4BoxParsers.toHex_(reader.readUint8()) +
+        Mp4BoxParsers.toHex_(reader.readUint8());
+    return {codec};
+  }
+
+  /**
+   * Parses a HVCC box.
+   * @param {string} codecBase
+   * @param {!shaka.util.DataViewReader} reader
+   * @param {string} boxName
+   * @return {!shaka.util.ParsedHVCCBox}
+   */
+  static parseHVCC(codecBase, reader, boxName) {
+    const Mp4BoxParsers = shaka.util.Mp4BoxParsers;
+    reader.skip(1); // Skip "configurationVersion"
+    const profileByte = reader.readUint8();
+    const profileSpace = ['', 'A', 'B', 'C'][profileByte >> 6];
+    const generalProfileIdc = profileByte & 0x1f;
+    const profileCompat = reader.readUint32();
+    const tierFlag = (profileByte & 0x20) >> 5 ? 'H' : 'L';
+    const constraintIndicator = [
+      reader.readUint8(),
+      reader.readUint8(),
+      reader.readUint8(),
+      reader.readUint8(),
+      reader.readUint8(),
+      reader.readUint8(),
+    ];
+    const levelIDC = reader.readUint8();
+    let codec = codecBase;
+    codec += '.' + profileSpace + generalProfileIdc;
+    codec += '.' + Mp4BoxParsers.toHex_(
+        Mp4BoxParsers.reverseBits_(profileCompat),
+        /* removeInitialZero= */ true);
+    codec += '.' + tierFlag + levelIDC;
+    let constraintString = '';
+    for (let i = constraintIndicator.length; i--; ) {
+      const byte = constraintIndicator[i];
+      if (byte || constraintString) {
+        const encodedByte = byte.toString(16).toUpperCase();
+        constraintString = '.' + encodedByte + constraintString;
+      }
+    }
+    codec += constraintString;
+
+    return {codec};
+  }
+
+  /**
+   * Parses a DVCC box.
+   * @param {string} codecBase
+   * @param {!shaka.util.DataViewReader} reader
+   * @param {string} boxName
+   * @return {!shaka.util.ParsedDVCCBox}
+   */
+  static parseDVCC(codecBase, reader, boxName) {
+    const Mp4BoxParsers = shaka.util.Mp4BoxParsers;
+    reader.skip(2); // Skip "dv_version_major" and "dv_version_minor"
+    const thirdByte = reader.readUint8();
+    const fourthByte = reader.readUint8();
+    const profile = (thirdByte >> 1) & 0x7f;
+    const level = ((thirdByte << 5) & 0x20) | ((fourthByte >> 3) & 0x1f);
+    const codec = codecBase + '.' +
+        Mp4BoxParsers.addLeadingZero_(profile) + '.' +
+        Mp4BoxParsers.addLeadingZero_(level);
+
+    return {codec};
+  }
+
+  /**
+   * Parses a VPCC box.
+   * @param {string} codecBase
+   * @param {!shaka.util.DataViewReader} reader
+   * @param {string} boxName
+   * @return {!shaka.util.ParsedVPCCBox}
+   */
+  static parseVPCC(codecBase, reader, boxName) {
+    const Mp4BoxParsers = shaka.util.Mp4BoxParsers;
+    const profile = reader.readUint8();
+    const level = reader.readUint8();
+    const bitDepth = (reader.readUint8() >> 4) & 0x0f;
+    const codec = codecBase + '.' +
+      Mp4BoxParsers.addLeadingZero_(profile) + '.' +
+      Mp4BoxParsers.addLeadingZero_(level) + '.' +
+      Mp4BoxParsers.addLeadingZero_(bitDepth);
+
+    return {codec};
+  }
+
+  /**
+   * Parses a AV1C box.
+   * @param {string} codecBase
+   * @param {!shaka.util.DataViewReader} reader
+   * @param {string} boxName
+   * @return {!shaka.util.ParsedAV1CBox}
+   */
+  static parseAV1C(codecBase, reader, boxName) {
+    const Mp4BoxParsers = shaka.util.Mp4BoxParsers;
+    // More info https://aomediacodec.github.io/av1-isobmff/#av1codecconfigurationbox-syntax
+    reader.skip(1); // Skip "marker" and "version"
+    const secondByte = reader.readUint8();
+    const thirdByte = reader.readUint8();
+    const profile = secondByte >>> 5;
+    const level = secondByte & 0x1f;
+    const tierFlag = thirdByte >>> 7 ? 'H' : 'M';
+    const highBitDepth = (thirdByte & 0x40) >> 6;
+    const twelveBit = (thirdByte & 0x20) >> 5;
+    const bitDepth = profile === 2 && highBitDepth ?
+        (twelveBit ? 12 : 10) : (highBitDepth ? 10 : 8);
+    const monochrome = (thirdByte & 0x10) >> 4;
+    const chromaSubsamplingX = (thirdByte & 0x08) >> 3;
+    const chromaSubsamplingY = (thirdByte & 0x04) >> 2;
+    const chromaSamplePosition = thirdByte & 0x03;
+    // TODO: parse color_description_present_flag
+    // default it to BT.709/limited range for now
+    const colorPrimaries = 1;
+    const transferCharacteristics = 1;
+    const matrixCoefficients = 1;
+    const videoFullRangeFlag = 0;
+    const codec = codecBase + '.' + profile +
+      '.' + Mp4BoxParsers.addLeadingZero_(level) + tierFlag +
+      '.' + Mp4BoxParsers.addLeadingZero_(bitDepth) +
+      '.' + monochrome +
+      '.' + chromaSubsamplingX + chromaSubsamplingY + chromaSamplePosition +
+      '.' + Mp4BoxParsers.addLeadingZero_(colorPrimaries) +
+      '.' + Mp4BoxParsers.addLeadingZero_(transferCharacteristics) +
+      '.' + Mp4BoxParsers.addLeadingZero_(matrixCoefficients) +
+      '.' + videoFullRangeFlag;
+
     return {codec};
   }
 
@@ -367,6 +499,21 @@ shaka.util.Mp4BoxParsers = class {
     return {codec};
   }
 
+  /**
+   * Parses a TENC box.
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {!shaka.util.ParsedTENCBox}
+   */
+  static parseTENC(reader) {
+    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
+    reader.readUint8(); // reserved
+    reader.readUint8();
+    reader.readUint8(); // default_isProtected
+    reader.readUint8(); // default_Per_Sample_IV_Size
+    const defaultKID = Uint8ArrayUtils.toHex(reader.readBytes(16));
+    return {defaultKID};
+  }
+
   /**
    * Parses a HDLR box.
    * @param {!shaka.util.DataViewReader} reader
@@ -375,24 +522,112 @@ shaka.util.Mp4BoxParsers = class {
   static parseHDLR(reader) {
     reader.skip(8); // Skip "pre_defined"
 
-    const data = reader.readBytes(4);
-    let handlerType = '';
-    handlerType += String.fromCharCode(data[0]);
-    handlerType += String.fromCharCode(data[1]);
-    handlerType += String.fromCharCode(data[2]);
-    handlerType += String.fromCharCode(data[3]);
-
+    const handlerType = reader.readTerminatedString();
     return {handlerType};
   }
 
+  /**
+   * Parses a PRJI box.
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {!shaka.util.ParsedPRJIBox}
+   */
+  static parsePRJI(reader) {
+    const projection = reader.readTerminatedString();
+    return {projection};
+  }
+
+  /**
+   * Parses a HFOV box.
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {!shaka.util.ParsedHFOVBox}
+   */
+  static parseHFOV(reader) {
+    const millidegrees = reader.readUint32();
+
+    return {
+      hfov: millidegrees / 1000,
+    };
+  }
+
+  /**
+   * Parses a COLR box.
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {!shaka.util.ParsedCOLRBox}
+   */
+  static parseCOLR(reader) {
+    let videoRange = null;
+    const data = reader.readBytes(4);
+    let colorType = '';
+    colorType += String.fromCharCode(data[0]);
+    colorType += String.fromCharCode(data[1]);
+    colorType += String.fromCharCode(data[2]);
+    colorType += String.fromCharCode(data[3]);
+    if (colorType === 'nclx') {
+      reader.readUint16(); // colour_primaries
+      const transferCharacteristics = reader.readUint16();
+      reader.readUint16(); // matrix_coefficients
+      switch (transferCharacteristics) {
+        case 1:
+        case 6:
+        case 13:
+        case 14:
+        case 15:
+          videoRange = 'SDR';
+          break;
+        case 16:
+          videoRange = 'PQ';
+          break;
+        case 18:
+          videoRange = 'HLG';
+          break;
+      }
+    }
+    return {videoRange};
+  }
+
   /**
    * Convert a number to hex
    * @param {number} x
+   * @param {boolean=} removeInitialZero
+   * @return {string}
+   * @private
+   */
+  static toHex_(x, removeInitialZero = false) {
+    const value = x.toString(16).toUpperCase();
+    if (removeInitialZero) {
+      return value;
+    }
+    return ('0' + value).slice(-2);
+  }
+
+  /**
+   * Reverse a number bit to bit
+   * @param {number} x
+   * @return {number}
+   * @private
+   */
+  static reverseBits_(x) {
+    let val = x;
+    let reversed = 0;
+    for (let i = 0; i < 32; i++) {
+      reversed |= val & 1;
+      if (i == 31) {
+        break;
+      }
+      reversed <<= 1;
+      val >>= 1;
+    }
+    return reversed;
+  }
+
+  /**
+   *
+   * @param {number} x
    * @return {string}
    * @private
    */
-  static toHex_(x) {
-    return ('0' + x.toString(16).toUpperCase()).slice(-2);
+  static addLeadingZero_(x) {
+    return (x < 10 ? '0' : '') + x;
   }
 };
 
@@ -544,6 +779,17 @@ shaka.util.ParsedTKHDBox;
  */
 shaka.util.ParsedFRMABox;
 
+/**
+ * @typedef {{
+ *    defaultKID: string
+ *  }}
+ *
+ * @property {string} defaultKID
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedTENCBox;
+
 /**
  * @typedef {{
  *    channelCount: number,
@@ -577,7 +823,51 @@ shaka.util.ParsedESDSBox;
  *
  * @exportDoc
  */
-shaka.util.ParsedAVCBox;
+shaka.util.ParsedAVCCBox;
+
+/**
+ * @typedef {{
+ *    codec: string
+ *  }}
+ *
+ * @property {string} codec
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedHVCCBox;
+
+/**
+ * @typedef {{
+ *    codec: string
+ *  }}
+ *
+ * @property {string} codec
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedDVCCBox;
+
+/**
+ * @typedef {{
+ *    codec: string
+ *  }}
+ *
+ * @property {string} codec
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedVPCCBox;
+
+/**
+ * @typedef {{
+ *    codec: string
+ *  }}
+ *
+ * @property {string} codec
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedAV1CBox;
 
 /**
  * @typedef {{
@@ -592,3 +882,42 @@ shaka.util.ParsedAVCBox;
  * @exportDoc
  */
 shaka.util.ParsedHDLRBox;
+
+/**
+ * @typedef {{
+ *    projection: string
+ * }}
+ *
+ * @property {string} projection
+ *   A four-character code that identifies the type of the projection.
+ *   Possible values:
+ *    - Rectangular: ‘rect’
+ *    - Half equirectangular: ‘hequ’
+ *    - Equirectanguler: ?
+ *    - Fisheye: ‘fish’
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedPRJIBox;
+
+/**
+ * @typedef {{
+ *    hfov: number
+ * }}
+ *
+ * @property {number} hfov
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedHFOVBox;
+
+/**
+ * @typedef {{
+ *    videoRange: ?string
+ * }}
+ *
+ * @property {?string} videoRange
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedCOLRBox;

package/lib/util/mp4_generator.js

@@ -314,6 +314,8 @@ shaka.util.Mp4Generator = class {
           bytes = this.ac3_(streamInfo);
         } else if (streamInfo.codecs.includes('ec-3')) {
           bytes = this.ec3_(streamInfo);
+        } else if (streamInfo.codecs.includes('opus')) {
+          bytes = this.opus_(streamInfo);
         } else {
           bytes = this.mp4a_(streamInfo);
         }
@@ -611,6 +613,27 @@ shaka.util.Mp4Generator = class {
         this.audioStsd_(streamInfo), dec3Box, sinfBox);
   }
 
+  /**
+   * Generate a Opus box
+   *
+   * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
+   * @return {!Uint8Array}
+   * @private
+   */
+  opus_(streamInfo) {
+    const Mp4Generator = shaka.util.Mp4Generator;
+    const dopsBox = Mp4Generator.box('dOps', streamInfo.audioConfig);
+
+    let boxName = 'Opus';
+    let sinfBox = new Uint8Array([]);
+    if (streamInfo.encrypted) {
+      sinfBox = this.sinf_(streamInfo);
+      boxName = 'enca';
+    }
+    return Mp4Generator.box(boxName,
+        this.audioStsd_(streamInfo), dopsBox, sinfBox);
+  }
+
   /**
    * Generate a MP4A box
    *

package/lib/util/periods.js

@@ -45,6 +45,9 @@ shaka.util.PeriodCombiner = class {
     /** @private {boolean} */
     this.multiTypeVariantsAllowed_ = false;
 
+    /** @private {boolean} */
+    this.useStreamOnce_ = false;
+
     /**
      * The IDs of the periods we have already used to generate streams.
      * This helps us identify the periods which have been added when a live
@@ -1008,6 +1011,12 @@ shaka.util.PeriodCombiner = class {
       }
     }
 
+    // Remove just found stream if configured to, so possible future linear
+    // searches can be faster.
+    if (this.useStreamOnce_ && !shaka.util.PeriodCombiner.isDummy_(best)) {
+      streams.delete(getKey(best));
+    }
+
     return best;
   }
 
@@ -1042,11 +1051,21 @@ shaka.util.PeriodCombiner = class {
   /**
    * @param {boolean} allowed If set to true, multi-mimeType or multi-codec
    *   variants will be allowed.
+   * @export
    */
   setAllowMultiTypeVariants(allowed) {
     this.multiTypeVariantsAllowed_ = allowed;
   }
 
+  /**
+   * @param {boolean} useOnce if true, stream will be used only once in period
+   *   flattening algoritnm.
+   * @export
+   */
+  setUseStreamOnce(useOnce) {
+    this.useStreamOnce_ = useOnce;
+  }
+
   /**
    * @param {T} outputStream An audio or video output stream
    * @param {T} candidate A candidate stream to be combined with the output