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.    * @return {shaka.extern.DrmInfo}
  65.    */
  66.   static createDrmInfo(keySystem, encryptionScheme, initData) {
  67.     return {
  68.       keySystem,
  69.       encryptionScheme,
  70.       licenseServerUri: '',
  71.       distinctiveIdentifierRequired: false,
  72.       persistentStateRequired: false,
  73.       audioRobustness: '',
  74.       videoRobustness: '',
  75.       serverCertificate: null,
  76.       serverCertificateUri: '',
  77.       sessionType: '',
  78.       initData: initData || [],
  79.       keyIds: new Set(),
  80.     };
  81.   }
  83.   /**
  84.    * Creates a DrmInfo object from ClearKeys.
  85.    *
  86.    * @param {!Map.<string, string>} clearKeys
  87.    * @param {string=} encryptionScheme
  88.    * @return {shaka.extern.DrmInfo}
  89.    */
  90.   static createDrmInfoFromClearKeys(clearKeys, encryptionScheme = 'cenc') {
  91.     const StringUtils = shaka.util.StringUtils;
  92.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  93.     const keys = [];
  94.     const keyIds = [];
  95.     const originalKeyIds = [];
  97.     clearKeys.forEach((key, keyId) => {
  98.       let kid = keyId;
  99.       if (kid.length != 22) {
  100.         kid = Uint8ArrayUtils.toBase64(
  101.             Uint8ArrayUtils.fromHex(keyId), false);
  102.       }
  103.       let k = key;
  104.       if (k.length != 22) {
  105.         k = Uint8ArrayUtils.toBase64(
  106.             Uint8ArrayUtils.fromHex(key), false);
  107.       }
  108.       const keyObj = {
  109.         kty: 'oct',
  110.         kid: kid,
  111.         k: k,
  112.       };
  114.       keys.push(keyObj);
  115.       keyIds.push(keyObj.kid);
  116.       originalKeyIds.push(keyId);
  117.     });
  119.     const jwkSet = {keys: keys};
  120.     const license = JSON.stringify(jwkSet);
  122.     // Use the keyids init data since is suggested by EME.
  123.     // Suggestion: https://bit.ly/2JYcNTu
  124.     // Format: https://www.w3.org/TR/eme-initdata-keyids/
  125.     const initDataStr = JSON.stringify({'kids': keyIds});
  126.     const initData =
  127.         shaka.util.BufferUtils.toUint8(StringUtils.toUTF8(initDataStr));
  128.     const initDatas = [{initData: initData, initDataType: 'keyids'}];
  130.     return {
  131.       keySystem: 'org.w3.clearkey',
  132.       encryptionScheme,
  133.       licenseServerUri: 'data:application/json;base64,' + window.btoa(license),
  134.       distinctiveIdentifierRequired: false,
  135.       persistentStateRequired: false,
  136.       audioRobustness: '',
  137.       videoRobustness: '',
  138.       serverCertificate: null,
  139.       serverCertificateUri: '',
  140.       sessionType: '',
  141.       initData: initDatas,
  142.       keyIds: new Set(originalKeyIds),
  143.     };
  144.   }
  147.   /**
  148.    * Attempts to guess which codecs from the codecs list belong to a given
  149.    * content type.
  150.    * Assumes that at least one codec is correct, and throws if none are.
  151.    *
  152.    * @param {string} contentType
  153.    * @param {!Array.<string>} codecs
  154.    * @return {string}
  155.    */
  156.   static guessCodecs(contentType, codecs) {
  157.     if (codecs.length == 1) {
  158.       return codecs[0];
  159.     }
  161.     const match = shaka.util.ManifestParserUtils.guessCodecsSafe(
  162.         contentType, codecs);
  163.     // A failure is specifically denoted by null; an empty string represents a
  164.     // valid match of no codec.
  165.     if (match != null) {
  166.       return match;
  167.     }
  169.     // Unable to guess codecs.
  170.     throw new shaka.util.Error(
  171.         shaka.util.Error.Severity.CRITICAL,
  172.         shaka.util.Error.Category.MANIFEST,
  173.         shaka.util.Error.Code.HLS_COULD_NOT_GUESS_CODECS,
  174.         codecs);
  175.   }
  178.   /**
  179.    * Attempts to guess which codecs from the codecs list belong to a given
  180.    * content type. Does not assume a single codec is anything special, and does
  181.    * not throw if it fails to match.
  182.    *
  183.    * @param {string} contentType
  184.    * @param {!Array.<string>} codecs
  185.    * @return {?string} or null if no match is found
  186.    */
  187.   static guessCodecsSafe(contentType, codecs) {
  188.     const formats = shaka.util.ManifestParserUtils
  189.         .CODEC_REGEXPS_BY_CONTENT_TYPE_[contentType];
  190.     for (const format of formats) {
  191.       for (const codec of codecs) {
  192.         if (format.test(codec.trim())) {
  193.           return codec.trim();
  194.         }
  195.       }
  196.     }
  198.     // Text does not require a codec string.
  199.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  200.       return '';
  201.     }
  203.     return null;
  204.   }
  207.   /**
  208.    * Attempts to guess which codecs from the codecs list belong to a given
  209.    * content.
  210.    *
  211.    * @param {string} contentType
  212.    * @param {!Array.<string>} codecs
  213.    * @return {!Array.<string>}
  214.    */
  215.   static guessAllCodecsSafe(contentType, codecs) {
  216.     const allCodecs = [];
  217.     const formats = shaka.util.ManifestParserUtils
  218.         .CODEC_REGEXPS_BY_CONTENT_TYPE_[contentType];
  219.     for (const format of formats) {
  220.       for (const codec of codecs) {
  221.         if (format.test(codec.trim())) {
  222.           allCodecs.push(codec.trim());
  223.         }
  224.       }
  225.     }
  227.     return allCodecs;
  228.   }
  229. };
  232. /**
  233.  * @enum {string}
  234.  */
  235. shaka.util.ManifestParserUtils.ContentType = {
  236.   VIDEO: 'video',
  237.   AUDIO: 'audio',
  238.   TEXT: 'text',
  239.   IMAGE: 'image',
  240.   APPLICATION: 'application',
  241. };
  244. /**
  245.  * @enum {string}
  246.  */
  247. shaka.util.ManifestParserUtils.TextStreamKind = {
  248.   SUBTITLE: 'subtitle',
  249.   CLOSED_CAPTION: 'caption',
  250. };
  253. /**
  254.  * Specifies how tolerant the player is of inaccurate segment start times and
  255.  * end times within a manifest. For example, gaps or overlaps between segments
  256.  * in a SegmentTimeline which are greater than or equal to this value will
  257.  * result in a warning message.
  258.  *
  259.  * @const {number}
  260.  */
  261. shaka.util.ManifestParserUtils.GAP_OVERLAP_TOLERANCE_SECONDS = 1 / 15;
  264. /**
  265.  * A list of regexps to detect well-known video codecs.
  266.  *
  267.  * @const {!Array.<!RegExp>}
  268.  * @private
  269.  */
  270. shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_ = [
  271.   /^avc/,
  272.   /^hev/,
  273.   /^hvc/,
  274.   /^vvc/,
  275.   /^vvi/,
  276.   /^vp0?[89]/,
  277.   /^av01/,
  278.   /^dvh/, // Dolby Vision based in HEVC
  279.   /^dva/, // Dolby Vision based in AVC
  280.   /^dav/, // Dolby Vision based in AV1
  281. ];
  284. /**
  285.  * A list of regexps to detect well-known audio codecs.
  286.  *
  287.  * @const {!Array.<!RegExp>}
  288.  * @private
  289.  */
  290. shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_ = [
  291.   /^vorbis$/,
  292.   /^Opus$/, // correct codec string according to RFC 6381 section 3.3
  293.   /^opus$/, // some manifests wrongfully use this
  294.   /^fLaC$/, // correct codec string according to RFC 6381 section 3.3
  295.   /^flac$/, // some manifests wrongfully use this
  296.   /^mp4a/,
  297.   /^[ae]c-3$/,
  298.   /^ac-4/,
  299.   /^dts[cex]$/, // DTS Digital Surround (dtsc), DTS Express (dtse), DTS:X (dtsx)
  300.   /^iamf/,
  301.   /^mhm[12]/, // MPEG-H Audio LC
  302. ];
  305. /**
  306.  * A list of regexps to detect well-known text codecs.
  307.  *
  308.  * @const {!Array.<!RegExp>}
  309.  * @private
  310.  */
  311. shaka.util.ManifestParserUtils.TEXT_CODEC_REGEXPS_ = [
  312.   /^vtt$/,
  313.   /^wvtt/,
  314.   /^stpp/,
  315. ];
  318. /**
  319.  * @const {!Object.<string, !Array.<!RegExp>>}
  320.  */
  321. shaka.util.ManifestParserUtils.CODEC_REGEXPS_BY_CONTENT_TYPE_ = {
  322.   'audio': shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_,
  323.   'video': shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_,
  324.   'text': shaka.util.ManifestParserUtils.TEXT_CODEC_REGEXPS_,
  325. };