Source: lib/util/manifest_parser_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.ManifestParserUtils');
  9. goog.require('goog.Uri');
  10. goog.require('shaka.util.BufferUtils');
  11. goog.require('shaka.util.Error');
  12. goog.require('shaka.util.StringUtils');
  13. goog.require('shaka.util.Uint8ArrayUtils');
  16. /**
  17.  * @summary Utility functions for manifest parsing.
  18.  */
  19. shaka.util.ManifestParserUtils = class {
  20.   /**
  21.    * Resolves an array of relative URIs to the given base URIs. This will result
  22.    * in M*N number of URIs.
  23.    *
  24.    * Note: This method is slow in SmartTVs and Consoles. It should only be
  25.    * called when necessary.
  26.    *
  27.    * @param {!Array.<string>} baseUris
  28.    * @param {!Array.<string>} relativeUris
  29.    * @return {!Array.<string>}
  30.    */
  31.   static resolveUris(baseUris, relativeUris) {
  32.     if (relativeUris.length == 0) {
  33.       return baseUris;
  34.     }
  36.     if (baseUris.length == 1 && relativeUris.length == 1) {
  37.       const baseUri = new goog.Uri(baseUris[0]);
  38.       const relativeUri = new goog.Uri(relativeUris[0]);
  39.       return [baseUri.resolve(relativeUri).toString()];
  40.     }
  42.     const relativeAsGoog = relativeUris.map((uri) => new goog.Uri(uri));
  44.     // For each base URI, this code resolves it with every relative URI.
  45.     // The result is a single array containing all the resolved URIs.
  46.     const resolvedUris = [];
  47.     for (const baseStr of baseUris) {
  48.       const base = new goog.Uri(baseStr);
  49.       for (const relative of relativeAsGoog) {
  50.         resolvedUris.push(base.resolve(relative).toString());
  51.       }
  52.     }
  54.     return resolvedUris;
  55.   }
  58.   /**
  59.    * Creates a DrmInfo object from the given info.
  60.    *
  61.    * @param {string} keySystem
  62.    * @param {string} encryptionScheme
  63.    * @param {Array.<shaka.extern.InitDataOverride>} initData
  64.    * @param {string} [keySystemUri]
  65.    * @return {shaka.extern.DrmInfo}
  66.    */
  67.   static createDrmInfo(keySystem, encryptionScheme, initData, keySystemUri) {
  68.     const drmInfo = {
  69.       keySystem,
  70.       encryptionScheme,
  71.       licenseServerUri: '',
  72.       distinctiveIdentifierRequired: false,
  73.       persistentStateRequired: false,
  74.       audioRobustness: '',
  75.       videoRobustness: '',
  76.       serverCertificate: null,
  77.       serverCertificateUri: '',
  78.       sessionType: '',
  79.       initData: initData || [],
  80.       keyIds: new Set(),
  81.     };
  83.     if (keySystemUri) {
  84.       drmInfo.keySystemUris = new Set([keySystemUri]);
  85.     }
  87.     return drmInfo;
  88.   }
  90.   /**
  91.    * Creates a DrmInfo object from ClearKeys.
  92.    *
  93.    * @param {!Map.<string, string>} clearKeys
  94.    * @param {string=} encryptionScheme
  95.    * @return {shaka.extern.DrmInfo}
  96.    */
  97.   static createDrmInfoFromClearKeys(clearKeys, encryptionScheme = 'cenc') {
  98.     const StringUtils = shaka.util.StringUtils;
  99.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  100.     const keys = [];
  101.     const keyIds = [];
  102.     const originalKeyIds = [];
  104.     clearKeys.forEach((key, keyId) => {
  105.       let kid = keyId;
  106.       if (kid.length != 22) {
  107.         kid = Uint8ArrayUtils.toBase64(
  108.             Uint8ArrayUtils.fromHex(keyId), false);
  109.       }
  110.       let k = key;
  111.       if (k.length != 22) {
  112.         k = Uint8ArrayUtils.toBase64(
  113.             Uint8ArrayUtils.fromHex(key), false);
  114.       }
  115.       const keyObj = {
  116.         kty: 'oct',
  117.         kid: kid,
  118.         k: k,
  119.       };
  121.       keys.push(keyObj);
  122.       keyIds.push(keyObj.kid);
  123.       originalKeyIds.push(keyId);
  124.     });
  126.     const jwkSet = {keys: keys};
  127.     const license = JSON.stringify(jwkSet);
  129.     // Use the keyids init data since is suggested by EME.
  130.     // Suggestion: https://bit.ly/2JYcNTu
  131.     // Format: https://www.w3.org/TR/eme-initdata-keyids/
  132.     const initDataStr = JSON.stringify({'kids': keyIds});
  133.     const initData =
  134.         shaka.util.BufferUtils.toUint8(StringUtils.toUTF8(initDataStr));
  135.     const initDatas = [{initData: initData, initDataType: 'keyids'}];
  137.     return {
  138.       keySystem: 'org.w3.clearkey',
  139.       encryptionScheme,
  140.       licenseServerUri: 'data:application/json;base64,' + window.btoa(license),
  141.       distinctiveIdentifierRequired: false,
  142.       persistentStateRequired: false,
  143.       audioRobustness: '',
  144.       videoRobustness: '',
  145.       serverCertificate: null,
  146.       serverCertificateUri: '',
  147.       sessionType: '',
  148.       initData: initDatas,
  149.       keyIds: new Set(originalKeyIds),
  150.     };
  151.   }
  154.   /**
  155.    * Attempts to guess which codecs from the codecs list belong to a given
  156.    * content type.
  157.    * Assumes that at least one codec is correct, and throws if none are.
  158.    *
  159.    * @param {string} contentType
  160.    * @param {!Array.<string>} codecs
  161.    * @return {string}
  162.    */
  163.   static guessCodecs(contentType, codecs) {
  164.     if (codecs.length == 1) {
  165.       return codecs[0];
  166.     }
  168.     const match = shaka.util.ManifestParserUtils.guessCodecsSafe(
  169.         contentType, codecs);
  170.     // A failure is specifically denoted by null; an empty string represents a
  171.     // valid match of no codec.
  172.     if (match != null) {
  173.       return match;
  174.     }
  176.     // Unable to guess codecs.
  177.     throw new shaka.util.Error(
  178.         shaka.util.Error.Severity.CRITICAL,
  179.         shaka.util.Error.Category.MANIFEST,
  180.         shaka.util.Error.Code.HLS_COULD_NOT_GUESS_CODECS,
  181.         codecs);
  182.   }
  185.   /**
  186.    * Attempts to guess which codecs from the codecs list belong to a given
  187.    * content type. Does not assume a single codec is anything special, and does
  188.    * not throw if it fails to match.
  189.    *
  190.    * @param {string} contentType
  191.    * @param {!Array.<string>} codecs
  192.    * @return {?string} or null if no match is found
  193.    */
  194.   static guessCodecsSafe(contentType, codecs) {
  195.     const formats = shaka.util.ManifestParserUtils
  196.         .CODEC_REGEXPS_BY_CONTENT_TYPE_[contentType];
  197.     for (const format of formats) {
  198.       for (const codec of codecs) {
  199.         if (format.test(codec.trim())) {
  200.           return codec.trim();
  201.         }
  202.       }
  203.     }
  205.     // Text does not require a codec string.
  206.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  207.       return '';
  208.     }
  210.     return null;
  211.   }
  214.   /**
  215.    * Attempts to guess which codecs from the codecs list belong to a given
  216.    * content.
  217.    *
  218.    * @param {string} contentType
  219.    * @param {!Array.<string>} codecs
  220.    * @return {!Array.<string>}
  221.    */
  222.   static guessAllCodecsSafe(contentType, codecs) {
  223.     const allCodecs = [];
  224.     const formats = shaka.util.ManifestParserUtils
  225.         .CODEC_REGEXPS_BY_CONTENT_TYPE_[contentType];
  226.     for (const format of formats) {
  227.       for (const codec of codecs) {
  228.         if (format.test(codec.trim())) {
  229.           allCodecs.push(codec.trim());
  230.         }
  231.       }
  232.     }
  234.     return allCodecs;
  235.   }
  236. };
  239. /**
  240.  * @enum {string}
  241.  */
  242. shaka.util.ManifestParserUtils.ContentType = {
  243.   VIDEO: 'video',
  244.   AUDIO: 'audio',
  245.   TEXT: 'text',
  246.   IMAGE: 'image',
  247.   APPLICATION: 'application',
  248. };
  251. /**
  252.  * @enum {string}
  253.  */
  254. shaka.util.ManifestParserUtils.TextStreamKind = {
  255.   SUBTITLE: 'subtitle',
  256.   CLOSED_CAPTION: 'caption',
  257. };
  260. /**
  261.  * Specifies how tolerant the player is of inaccurate segment start times and
  262.  * end times within a manifest. For example, gaps or overlaps between segments
  263.  * in a SegmentTimeline which are greater than or equal to this value will
  264.  * result in a warning message.
  265.  *
  266.  * @const {number}
  267.  */
  268. shaka.util.ManifestParserUtils.GAP_OVERLAP_TOLERANCE_SECONDS = 1 / 15;
  271. /**
  272.  * A list of regexps to detect well-known video codecs.
  273.  *
  274.  * @const {!Array.<!RegExp>}
  275.  * @private
  276.  */
  277. shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_ = [
  278.   /^avc/,
  279.   /^hev/,
  280.   /^hvc/,
  281.   /^vvc/,
  282.   /^vvi/,
  283.   /^vp0?[89]/,
  284.   /^av01/,
  285.   /^dvh/, // Dolby Vision based in HEVC
  286.   /^dva/, // Dolby Vision based in AVC
  287.   /^dav/, // Dolby Vision based in AV1
  288. ];
  291. /**
  292.  * A list of regexps to detect well-known audio codecs.
  293.  *
  294.  * @const {!Array.<!RegExp>}
  295.  * @private
  296.  */
  297. shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_ = [
  298.   /^vorbis$/,
  299.   /^Opus$/, // correct codec string according to RFC 6381 section 3.3
  300.   /^opus$/, // some manifests wrongfully use this
  301.   /^fLaC$/, // correct codec string according to RFC 6381 section 3.3
  302.   /^flac$/, // some manifests wrongfully use this
  303.   /^mp4a/,
  304.   /^[ae]c-3$/,
  305.   /^ac-4/,
  306.   /^dts[cex]$/, // DTS Digital Surround (dtsc), DTS Express (dtse), DTS:X (dtsx)
  307.   /^iamf/,
  308.   /^mhm[12]/, // MPEG-H Audio LC
  309. ];
  312. /**
  313.  * A list of regexps to detect well-known text codecs.
  314.  *
  315.  * @const {!Array.<!RegExp>}
  316.  * @private
  317.  */
  318. shaka.util.ManifestParserUtils.TEXT_CODEC_REGEXPS_ = [
  319.   /^vtt$/,
  320.   /^wvtt/,
  321.   /^stpp/,
  322. ];
  325. /**
  326.  * @const {!Object.<string, !Array.<!RegExp>>}
  327.  */
  328. shaka.util.ManifestParserUtils.CODEC_REGEXPS_BY_CONTENT_TYPE_ = {
  329.   'audio': shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_,
  330.   'video': shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_,
  331.   'text': shaka.util.ManifestParserUtils.TEXT_CODEC_REGEXPS_,
  332. };