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.Error');
  11. goog.require('shaka.util.Functional');
  14. /**
  15.  * @summary Utility functions for manifest parsing.
  16.  */
  17. shaka.util.ManifestParserUtils = class {
  18.   /**
  19.    * Resolves an array of relative URIs to the given base URIs. This will result
  20.    * in M*N number of URIs.
  21.    *
  22.    * @param {!Array.<string>} baseUris
  23.    * @param {!Array.<string>} relativeUris
  24.    * @return {!Array.<string>}
  25.    */
  26.   static resolveUris(baseUris, relativeUris) {
  27.     const Functional = shaka.util.Functional;
  28.     if (relativeUris.length == 0) {
  29.       return baseUris;
  30.     }
  32.     const relativeAsGoog = relativeUris.map((uri) => new goog.Uri(uri));
  33.     // Resolve each URI relative to each base URI, creating an Array of Arrays.
  34.     // Then flatten the Arrays into a single Array.
  35.     return baseUris.map((uri) => new goog.Uri(uri))
  36.         .map((base) => relativeAsGoog.map((i) => base.resolve(i)))
  37.         .reduce(Functional.collapseArrays, [])
  38.         .map((uri) => uri.toString());
  39.   }
  42.   /**
  43.    * Creates a DrmInfo object from the given info.
  44.    *
  45.    * @param {string} keySystem
  46.    * @param {Array.<shaka.extern.InitDataOverride>} initData
  47.    * @return {shaka.extern.DrmInfo}
  48.    */
  49.   static createDrmInfo(keySystem, initData) {
  50.     return {
  51.       keySystem: keySystem,
  52.       licenseServerUri: '',
  53.       distinctiveIdentifierRequired: false,
  54.       persistentStateRequired: false,
  55.       audioRobustness: '',
  56.       videoRobustness: '',
  57.       serverCertificate: null,
  58.       serverCertificateUri: '',
  59.       sessionType: '',
  60.       initData: initData || [],
  61.       keyIds: new Set(),
  62.     };
  63.   }
  66.   /**
  67.    * Attempts to guess which codecs from the codecs list belong to a given
  68.    * content type.
  69.    * Assumes that at least one codec is correct, and throws if none are.
  70.    *
  71.    * @param {string} contentType
  72.    * @param {!Array.<string>} codecs
  73.    * @return {string}
  74.    */
  75.   static guessCodecs(contentType, codecs) {
  76.     if (codecs.length == 1) {
  77.       return codecs[0];
  78.     }
  80.     const match = shaka.util.ManifestParserUtils.guessCodecsSafe(
  81.         contentType, codecs);
  82.     // A failure is specifically denoted by null; an empty string represents a
  83.     // valid match of no codec.
  84.     if (match != null) {
  85.       return match;
  86.     }
  88.     // Unable to guess codecs.
  89.     throw new shaka.util.Error(
  90.         shaka.util.Error.Severity.CRITICAL,
  91.         shaka.util.Error.Category.MANIFEST,
  92.         shaka.util.Error.Code.HLS_COULD_NOT_GUESS_CODECS,
  93.         codecs);
  94.   }
  97.   /**
  98.    * Attempts to guess which codecs from the codecs list belong to a given
  99.    * content type. Does not assume a single codec is anything special, and does
  100.    * not throw if it fails to match.
  101.    *
  102.    * @param {string} contentType
  103.    * @param {!Array.<string>} codecs
  104.    * @return {?string} or null if no match is found
  105.    */
  106.   static guessCodecsSafe(contentType, codecs) {
  107.     const formats = shaka.util.ManifestParserUtils
  108.         .CODEC_REGEXPS_BY_CONTENT_TYPE_[contentType];
  109.     for (const format of formats) {
  110.       for (const codec of codecs) {
  111.         if (format.test(codec.trim())) {
  112.           return codec.trim();
  113.         }
  114.       }
  115.     }
  117.     // Text does not require a codec string.
  118.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  119.       return '';
  120.     }
  122.     return null;
  123.   }
  124. };
  127. /**
  128.  * @enum {string}
  129.  */
  130. shaka.util.ManifestParserUtils.ContentType = {
  131.   VIDEO: 'video',
  132.   AUDIO: 'audio',
  133.   TEXT: 'text',
  134.   IMAGE: 'image',
  135.   APPLICATION: 'application',
  136. };
  139. /**
  140.  * @enum {string}
  141.  */
  142. shaka.util.ManifestParserUtils.TextStreamKind = {
  143.   SUBTITLE: 'subtitle',
  144.   CLOSED_CAPTION: 'caption',
  145. };
  148. /**
  149.  * Specifies how tolerant the player is of inaccurate segment start times and
  150.  * end times within a manifest. For example, gaps or overlaps between segments
  151.  * in a SegmentTimeline which are greater than or equal to this value will
  152.  * result in a warning message.
  153.  *
  154.  * @const {number}
  155.  */
  156. shaka.util.ManifestParserUtils.GAP_OVERLAP_TOLERANCE_SECONDS = 1 / 15;
  159. /**
  160.  * A list of regexps to detect well-known video codecs.
  161.  *
  162.  * @const {!Array.<!RegExp>}
  163.  * @private
  164.  */
  165. shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_ = [
  166.   /^avc/,
  167.   /^hev/,
  168.   /^hvc/,
  169.   /^vp0?[89]/,
  170.   /^av01/,
  171. ];
  174. /**
  175.  * A list of regexps to detect well-known audio codecs.
  176.  *
  177.  * @const {!Array.<!RegExp>}
  178.  * @private
  179.  */
  180. shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_ = [
  181.   /^vorbis$/,
  182.   /^opus$/,
  183.   /^flac$/,
  184.   /^mp4a/,
  185.   /^[ae]c-3$/,
  186. ];
  189. /**
  190.  * A list of regexps to detect well-known text codecs.
  191.  *
  192.  * @const {!Array.<!RegExp>}
  193.  * @private
  194.  */
  195. shaka.util.ManifestParserUtils.TEXT_CODEC_REGEXPS_ = [
  196.   /^vtt$/,
  197.   /^wvtt/,
  198.   /^stpp/,
  199. ];
  202. /**
  203.  * @const {!Object.<string, !Array.<!RegExp>>}
  204.  */
  205. shaka.util.ManifestParserUtils.CODEC_REGEXPS_BY_CONTENT_TYPE_ = {
  206.   'audio': shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_,
  207.   'video': shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_,
  208.   'text': shaka.util.ManifestParserUtils.TEXT_CODEC_REGEXPS_,
  209. };