shaka-player 4.3.9 → 4.4.0

package/lib/util/fairplay_utils.js

@@ -133,14 +133,14 @@ shaka.util.FairPlayUtils = class {
   }
 
   /**
-   * Verimatrix initDataTransform configuration.
+   * Basic initDataTransform configuration.
    *
    * @param {!Uint8Array} initData
    * @param {string} initDataType
    * @param {?shaka.extern.DrmInfo} drmInfo
-   * @export
+   * @private
    */
-  static verimatrixInitDataTransform(initData, initDataType, drmInfo) {
+  static basicInitDataTransform_(initData, initDataType, drmInfo) {
     if (initDataType !== 'skd') {
       return initData;
     }
@@ -152,6 +152,19 @@ shaka.util.FairPlayUtils = class {
     return FairPlayUtils.initDataTransform(initData, contentId, cert);
   }
 
+  /**
+   * Verimatrix initDataTransform configuration.
+   *
+   * @param {!Uint8Array} initData
+   * @param {string} initDataType
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   * @export
+   */
+  static verimatrixInitDataTransform(initData, initDataType, drmInfo) {
+    return shaka.util.FairPlayUtils.basicInitDataTransform_(
+        initData, initDataType, drmInfo);
+  }
+
   /**
    * EZDRM initDataTransform configuration.
    *
@@ -202,14 +215,28 @@ shaka.util.FairPlayUtils = class {
     return FairPlayUtils.initDataTransform(initData, contentId, cert);
   }
 
+  /**
+   * ExpressPlay initDataTransform configuration.
+   *
+   * @param {!Uint8Array} initData
+   * @param {string} initDataType
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   * @export
+   */
+  static expressplayInitDataTransform(initData, initDataType, drmInfo) {
+    return shaka.util.FairPlayUtils.basicInitDataTransform_(
+        initData, initDataType, drmInfo);
+  }
+
   /**
    * Verimatrix FairPlay request.
    *
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
    * @export
    */
-  static verimatrixFairPlayRequest(type, request) {
+  static verimatrixFairPlayRequest(type, request, context) {
     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
       return;
     }
@@ -221,31 +248,54 @@ shaka.util.FairPlayUtils = class {
   }
 
   /**
-   * EZDRM FairPlay request.
+   * Set content-type to application/octet-stream in a FairPlay request.
    *
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Request} request
-   * @export
+   * @param {shaka.extern.RequestContext=} context
+   * @private
    */
-  static ezdrmFairPlayRequest(type, request) {
+  static octetStreamFairPlayRequest_(type, request, context) {
     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
       return;
     }
     request.headers['Content-Type'] = 'application/octet-stream';
   }
 
+  /**
+   * EZDRM FairPlay request.
+   *
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
+   * @export
+   */
+  static ezdrmFairPlayRequest(type, request, context) {
+    shaka.util.FairPlayUtils.octetStreamFairPlayRequest_(type, request);
+  }
+
   /**
    * Conax FairPlay request.
    *
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
    * @export
    */
-  static conaxFairPlayRequest(type, request) {
-    if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
-      return;
-    }
-    request.headers['Content-Type'] = 'application/octet-stream';
+  static conaxFairPlayRequest(type, request, context) {
+    shaka.util.FairPlayUtils.octetStreamFairPlayRequest_(type, request);
+  }
+
+  /**
+   * ExpressPlay FairPlay request.
+   *
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.Request} request
+   * @param {shaka.extern.RequestContext=} context
+   * @export
+   */
+  static expressplayFairPlayRequest(type, request, context) {
+    shaka.util.FairPlayUtils.octetStreamFairPlayRequest_(type, request);
   }
 
   /**
@@ -253,9 +303,10 @@ shaka.util.FairPlayUtils = class {
    *
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Response} response
+   * @param {shaka.extern.RequestContext=} context
    * @export
    */
-  static commonFairPlayResponse(type, response) {
+  static commonFairPlayResponse(type, response, context) {
     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
       return;
     }

package/lib/util/id3_utils.js

@@ -211,10 +211,26 @@ shaka.util.Id3Utils = class {
       }
       const text = StringUtils.fromUTF8(
           BufferUtils.toUint8(frame.data, 0, textEndIndex));
-      const data = BufferUtils.toArrayBuffer(
-          frame.data.subarray(text.length + 1));
       metadataFrame.description = text;
-      metadataFrame.data = data;
+      if (text == 'com.apple.streaming.transportStreamTimestamp') {
+        const data = frame.data.subarray(text.length + 1);
+        // timestamp is 33 bit expressed as a big-endian eight-octet number,
+        // with the upper 31 bits set to zero.
+        const pts33Bit = data[3] & 0x1;
+        let timestamp =
+          (data[4] << 23) + (data[5] << 15) + (data[6] << 7) + data[7];
+        timestamp /= 45;
+
+        if (pts33Bit) {
+          timestamp += 47721858.84;
+        } // 2^32 / 90
+
+        metadataFrame.data = timestamp;
+      } else {
+        const data = BufferUtils.toArrayBuffer(
+            frame.data.subarray(text.length + 1));
+        metadataFrame.data = data;
+      }
       return metadataFrame;
     } else if (frame.type[0] === 'T') {
       /*
@@ -291,6 +307,43 @@ shaka.util.Id3Utils = class {
     }
     return frames;
   }
+
+  /**
+   * Returns any adjacent ID3 tags found in data starting at offset, as one
+   * block of data
+   * @param {Uint8Array} id3Data - The ID3 data containing one or more ID3 tags
+   * @param {number=} offset - The offset at which to start searching
+   * @return {!Uint8Array}
+   * @export
+   */
+  static getID3Data(id3Data, offset = 0) {
+    const Id3Utils = shaka.util.Id3Utils;
+    const front = offset;
+    let length = 0;
+
+    while (Id3Utils.isHeader_(id3Data, offset)) {
+      if ((id3Data[offset + 5] >> 6) & 1) {
+        // skip extended header
+        length += 10;
+      }
+      // skip past ID3 header
+      length += 10;
+
+      const size = Id3Utils.readSize_(id3Data, offset + 6);
+      length += size;
+
+      if (Id3Utils.isFooter_(id3Data, offset + 10)) {
+        // ID3 footer is 10 bytes
+        length += 10;
+      }
+      offset += length;
+    }
+
+    if (length > 0) {
+      return id3Data.subarray(front, front + length);
+    }
+    return new Uint8Array([]);
+  }
 };
 
 /**

package/lib/util/language_utils.js

@@ -191,12 +191,16 @@ shaka.util.LanguageUtils = class {
   static normalize(locale) {
     const LanguageUtils = shaka.util.LanguageUtils;
 
-    const components = locale.split('-');
+    const privateusePrefix = 'x-';
+    const components = locale.split(`-${privateusePrefix}`);
+    const languageAndRegion = components[0].split('-');
 
-    // We are only going to use the language and the region. If there was
-    // a dialect or anything else, we are throwing it a way.
-    let language = components[0] || '';
-    let region = components[1] || '';
+    // We are only going to use the language, the region and the "privateuse" part (as per https://datatracker.ietf.org/doc/html/rfc5646).
+    // Anything else is thrown away.
+    let language = languageAndRegion[0] || '';
+    let region = languageAndRegion[1] || '';
+    const privateuse = components[1] ?
+        `${privateusePrefix}${components[1]}` : '';
 
     // Convert the language to lower case. It is standard for the language code
     // to be in lower case, but it will also make the map look-up easier.
@@ -208,9 +212,8 @@ shaka.util.LanguageUtils = class {
     // and this will be a no-op.
     region = region.toUpperCase();
 
-    return region ?
-           language + '-' + region :
-           language;
+    return `${region ? `${language}-${region}` : language}${
+        privateuse ? `-${privateuse}` : ''}`;
   }
 
   /**

package/lib/util/manifest_parser_utils.js

@@ -19,6 +19,9 @@ shaka.util.ManifestParserUtils = class {
    * Resolves an array of relative URIs to the given base URIs. This will result
    * in M*N number of URIs.
    *
+   * Note: This method is slow in SmartTVs and Consoles. It should only be
+   * called when necessary.
+   *
    * @param {!Array.<string>} baseUris
    * @param {!Array.<string>} relativeUris
    * @return {!Array.<string>}

package/lib/util/mime_utils.js

@@ -6,7 +6,7 @@
 
 goog.provide('shaka.util.MimeUtils');
 
-goog.require('shaka.media.Transmuxer');
+goog.require('shaka.transmuxer.TransmuxerEngine');
 goog.require('shaka.util.ManifestParserUtils');
 
 /**
@@ -16,7 +16,7 @@ goog.require('shaka.util.ManifestParserUtils');
 shaka.util.MimeUtils = class {
   /**
    * Takes a MIME type and optional codecs string and produces the full MIME
-   * type.
+   * type. Also remove the codecs for raw formats.
    *
    * @param {string} mimeType
    * @param {string=} codecs
@@ -24,6 +24,23 @@ shaka.util.MimeUtils = class {
    * @export
    */
   static getFullType(mimeType, codecs) {
+    let fullMimeType = mimeType;
+    if (codecs && !shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType)) {
+      fullMimeType += '; codecs="' + codecs + '"';
+    }
+    return fullMimeType;
+  }
+
+  /**
+   * Takes a MIME type and optional codecs string and produces the full MIME
+   * type.
+   *
+   * @param {string} mimeType
+   * @param {string=} codecs
+   * @return {string}
+   * @export
+   */
+  static getFullTypeWithAllCodecs(mimeType, codecs) {
     let fullMimeType = mimeType;
     if (codecs) {
       fullMimeType += '; codecs="' + codecs + '"';
@@ -43,12 +60,16 @@ shaka.util.MimeUtils = class {
    * @return {string}
    */
   static getFullOrConvertedType(mimeType, codecs, contentType) {
-    const fullMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
+    const MimeUtils = shaka.util.MimeUtils;
+    const fullMimeType = MimeUtils.getFullType(mimeType, codecs);
+    const fullMimeTypeWithAllCodecs = MimeUtils.getFullTypeWithAllCodecs(
+        mimeType, codecs);
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
-    const Transmuxer = shaka.media.Transmuxer;
+    const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
 
-    if (Transmuxer.isSupported(fullMimeType, contentType)) {
-      return shaka.media.Transmuxer.convertCodecs(contentType, fullMimeType);
+    if (TransmuxerEngine.isSupported(fullMimeTypeWithAllCodecs, contentType)) {
+      return TransmuxerEngine.convertCodecs(
+          contentType, fullMimeTypeWithAllCodecs);
     } else if (mimeType != 'video/mp2t' && contentType == ContentType.AUDIO) {
       // video/mp2t is the correct mime type for TS audio, so only replace the
       // word "video" with "audio" for non-TS audio content.
@@ -71,7 +92,10 @@ shaka.util.MimeUtils = class {
     const extendedMimeParams = shaka.util.MimeUtils.EXTENDED_MIME_PARAMETERS_;
     extendedMimeParams.forEach((mimeKey, streamKey) => {
       const value = stream[streamKey];
-      if (value) {
+      if (streamKey == 'codecs' &&
+          shaka.util.MimeUtils.RAW_FORMATS.includes(stream.mimeType)) {
+        // Skip codecs for raw formats
+      } else if (value) {
         components.push(mimeKey + '="' + value + '"');
       }
     });
@@ -117,6 +141,7 @@ shaka.util.MimeUtils = class {
     switch (true) {
       case base === 'mp4a' && profile === '69':
       case base === 'mp4a' && profile === '6b':
+      case base === 'mp4a' && profile === '40.34':
         return 'mp3';
       case base === 'mp4a' && profile === '66':
       case base === 'mp4a' && profile === '67':
@@ -254,3 +279,15 @@ shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE = 'application/cea-608';
  * @const {string}
  */
 shaka.util.MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE = 'application/cea-708';
+
+/**
+ * MIME types of raw formats.
+ *
+ * @const {!Array.<string>}
+ */
+shaka.util.MimeUtils.RAW_FORMATS = [
+  'audio/aac',
+  'audio/ac3',
+  'audio/ec3',
+  'audio/mpeg',
+];

package/lib/util/mp4_box_parsers.js

@@ -66,6 +66,59 @@ shaka.util.Mp4BoxParsers = class {
     };
   }
 
+  /**
+   * Parses a TFDT Box, with a loss of precision beyond 53 bits.
+   * Use only when exact integers are not required, e.g. when
+   * dividing by the timescale.
+   *
+   * @param {!shaka.util.DataViewReader} reader
+   * @param {number} version
+   * @return {!shaka.util.ParsedTFDTBox}
+   */
+  static parseTFDTInaccurate(reader, version) {
+    if (version == 1) {
+      const high = reader.readUint32();
+      const low = reader.readUint32();
+      return {
+        baseMediaDecodeTime: (high * Math.pow(2, 32)) + low,
+      };
+    } else {
+      return {
+        baseMediaDecodeTime: reader.readUint32(),
+      };
+    }
+  }
+
+  /**
+   * Parses a PRFT Box, with a loss of precision beyond 53 bits.
+   * Use only when exact integers are not required, e.g. when
+   * dividing by the timescale.
+   *
+   * @param {!shaka.util.DataViewReader} reader
+   * @param {number} version
+   * @return {!shaka.util.ParsedPRFTBox}
+   */
+  static parsePRFTInaccurate(reader, version) {
+    reader.readUint32(); // Ignore referenceTrackId
+    const ntpTimestampSec = reader.readUint32();
+    const ntpTimestampFrac = reader.readUint32();
+    const ntpTimestamp = ntpTimestampSec * 1000 +
+        ntpTimestampFrac / 2**32 * 1000;
+
+    let mediaTime;
+    if (version === 0) {
+      mediaTime = reader.readUint32();
+    } else {
+      const high = reader.readUint32();
+      const low = reader.readUint32();
+      mediaTime = (high * Math.pow(2, 32)) + low;
+    }
+    return {
+      mediaTime,
+      ntpTimestamp,
+    };
+  }
+
   /**
    * Parses a MDHD Box.
    * @param {!shaka.util.DataViewReader} reader
@@ -83,8 +136,21 @@ shaka.util.Mp4BoxParsers = class {
 
     const timescale = reader.readUint32();
 
+    reader.skip(4); // Skip "duration"
+
+    const language = reader.readUint16();
+
+    // language is stored as an ISO-639-2/T code in an array of three
+    // 5-bit fields each field is the packed difference between its ASCII
+    // value and 0x60
+    const languageString =
+        String.fromCharCode((language >> 10) + 0x60) +
+        String.fromCharCode(((language & 0x03c0) >> 5) + 0x60) +
+        String.fromCharCode((language & 0x1f) + 0x60);
+
     return {
       timescale,
+      language: languageString,
     };
   }
 
@@ -174,22 +240,88 @@ shaka.util.Mp4BoxParsers = class {
    * @return {!shaka.util.ParsedTKHDBox}
    */
   static parseTKHD(reader, version) {
-    let trackId = 0;
     if (version == 1) {
       reader.skip(8); // Skip "creation_time"
       reader.skip(8); // Skip "modification_time"
-      trackId = reader.readUint32();
     } else {
       reader.skip(4); // Skip "creation_time"
       reader.skip(4); // Skip "modification_time"
-      trackId = reader.readUint32();
     }
 
+    const trackId = reader.readUint32();
+
+    if (version == 1) {
+      reader.skip(8); // Skip "reserved"
+    } else {
+      reader.skip(4); // Skip "reserved"
+    }
+    reader.skip(4); // Skip "duration"
+    reader.skip(8); // Skip "reserved"
+    reader.skip(2); // Skip "layer"
+    reader.skip(2); // Skip "alternate_group"
+    reader.skip(2); // Skip "volume"
+    reader.skip(2); // Skip "reserved"
+    reader.skip(36); // Skip "matrix_structure"
+
+    const width = reader.readUint16() + (reader.readUint16() / 16);
+    const height = reader.readUint16() + (reader.readUint16() / 16);
+
     return {
       trackId,
+      width,
+      height,
     };
   }
 
+  /**
+   * Parses a MP4A box.
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {!shaka.util.ParsedMP4ABox}
+   */
+  static parseMP4A(reader) {
+    reader.skip(6); // Skip "reserved"
+    reader.skip(2); // Skip "data_reference_index"
+    reader.skip(8); // Skip "reserved"
+    const channelCount = reader.readUint16();
+    reader.skip(2); // Skip "samplesize"
+    reader.skip(2); // Skip "pre_defined"
+    reader.skip(2); // Skip "reserved"
+    const sampleRate = reader.readUint16() + (reader.readUint16() / 65536);
+
+    return {
+      channelCount,
+      sampleRate,
+    };
+  }
+
+  /**
+   * Parses a ESDS box.
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {!shaka.util.ParsedESDSBox}
+   */
+  static parseESDS(reader) {
+    let codec = 'mp4a';
+    reader.skip(11);
+    codec += '.' + this.toHex_(reader.readUint8());
+    // this value is only a single digit
+    codec += '.' +
+        this.toHex_((reader.readUint8() >>> 2) & 0x3f).replace(/^0/, '');
+    return {codec};
+  }
+
+  /**
+   * Parses a AVC box.
+   * @param {!shaka.util.DataViewReader} reader
+   * @param {string} boxName
+   * @return {!shaka.util.ParsedAVCBox}
+   */
+  static parseAVC(reader, boxName) {
+    reader.skip(87);
+    const codec = boxName + '.' + this.toHex_(reader.readUint8()) +
+        this.toHex_(reader.readUint8()) + this.toHex_(reader.readUint8());
+    return {codec};
+  }
+
   /**
    * Parses a FRMA box.
    * @param {!shaka.util.DataViewReader} reader
@@ -200,6 +332,34 @@ shaka.util.Mp4BoxParsers = class {
     const codec = shaka.util.Mp4Parser.typeToString(fourcc);
     return {codec};
   }
+
+  /**
+   * Parses a HDLR box.
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {!shaka.util.ParsedHDLRBox}
+   */
+  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]);
+
+    return {handlerType};
+  }
+
+  /**
+   * Convert a number to hex
+   * @param {number} x
+   * @return {string}
+   * @private
+   */
+  static toHex_(x) {
+    return ('0' + x.toString(16).toUpperCase()).slice(-2);
+  }
 };
 
 
@@ -242,12 +402,25 @@ shaka.util.ParsedTFDTBox;
 
 /**
  * @typedef {{
- *    timescale: number
+ *    mediaTime: number,
+ *    ntpTimestamp: number
+ * }}
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedPRFTBox;
+
+/**
+ * @typedef {{
+ *    timescale: number,
+ *    language: string
  * }}
  *
  * @property {number} timescale
  *   As per the spec: an integer that specifies the time‐scale for this media;
  *   this is the number of time units that pass in one second
+ * @property {string} language
+ *   Language code for this media
  *
  * @exportDoc
  */
@@ -309,11 +482,17 @@ shaka.util.ParsedTRUNSample;
 
 /**
  * @typedef {{
- *    trackId: number
+ *    trackId: number,
+ *    width: number,
+ *    height: number
  *  }}
  *
  * @property {number} trackId
  *   Unique ID indicative of this track
+ * @property {number} width
+ *   Width of this track in pixels
+ * @property {number} height
+ *   Height of this track in pixels.
  *
  * @exportDoc
  */
@@ -330,3 +509,52 @@ shaka.util.ParsedTKHDBox;
  * @exportDoc
  */
 shaka.util.ParsedFRMABox;
+
+/**
+ * @typedef {{
+ *    channelCount: number,
+ *    sampleRate: number
+ *  }}
+ *
+ * @property {number} channelCount
+ * @property {number} sampleRate
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedMP4ABox;
+
+/**
+ * @typedef {{
+ *    codec: string
+ *  }}
+ *
+ * @property {string} codec
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedESDSBox;
+
+/**
+ * @typedef {{
+ *    codec: string
+ *  }}
+ *
+ * @property {string} codec
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedAVCBox;
+
+/**
+ * @typedef {{
+ *    handlerType: string
+ * }}
+ *
+ * @property {string} handlerType
+ *   A four-character code that identifies the type of the media handler or
+ *   data handler. For media handlers, this field defines the type of
+ *   data—for example, 'vide' for video data, 'soun' for sound data.
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedHDLRBox;