Source: lib/media/manifest_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.ManifestParser');
  9. goog.require('shaka.Deprecate');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.Error');
  12. goog.require('shaka.util.Platform');
  15. // TODO: revisit this when Closure Compiler supports partially-exported classes.
  16. /**
  17.  * @summary An interface to register manifest parsers.
  18.  * @export
  19.  */
  20. shaka.media.ManifestParser = class {
  21.   /**
  22.    * Registers a manifest parser by file extension.
  23.    *
  24.    * @param {string} extension The file extension of the manifest.
  25.    * @param {shaka.extern.ManifestParser.Factory} parserFactory The factory
  26.    *   used to create parser instances.
  27.    * @export
  28.    */
  29.   static registerParserByExtension(extension, parserFactory) {
  30.     shaka.Deprecate.deprecateFeature(5,
  31.         'ManifestParser.registerParserByExtension',
  32.         'Please use an ManifestParser with registerParserByMime function.');
  33.   }
  36.   /**
  37.    * Registers a manifest parser by MIME type.
  38.    *
  39.    * @param {string} mimeType The MIME type of the manifest.
  40.    * @param {shaka.extern.ManifestParser.Factory} parserFactory The factory
  41.    *   used to create parser instances.
  42.    * @export
  43.    */
  44.   static registerParserByMime(mimeType, parserFactory) {
  45.     shaka.media.ManifestParser.parsersByMime.set(mimeType, parserFactory);
  46.   }
  48.   /**
  49.    * Unregisters a manifest parser by MIME type.
  50.    *
  51.    * @param {string} mimeType The MIME type of the manifest.
  52.    * @export
  53.    */
  54.   static unregisterParserByMime(mimeType) {
  55.     shaka.media.ManifestParser.parsersByMime.delete(mimeType);
  56.   }
  59.   /**
  60.    * Returns a map of manifest support for well-known types.
  61.    *
  62.    * @return {!Object<string, boolean>}
  63.    */
  64.   static probeSupport() {
  65.     const ManifestParser = shaka.media.ManifestParser;
  66.     const support = {};
  68.     // Make sure all registered parsers are shown, but only for MSE-enabled
  69.     // platforms where our parsers matter.
  70.     if (shaka.util.Platform.supportsMediaSource()) {
  71.       for (const type of ManifestParser.parsersByMime.keys()) {
  72.         support[type] = true;
  73.       }
  74.     }
  76.     // Make sure all well-known types are tested as well, just to show an
  77.     // explicit false for things people might be expecting.
  78.     const testMimeTypes = [
  79.       // DASH
  80.       'application/dash+xml',
  81.       // HLS
  82.       'application/x-mpegurl',
  83.       'application/vnd.apple.mpegurl',
  84.       // SmoothStreaming
  85.       'application/vnd.ms-sstr+xml',
  86.     ];
  88.     for (const type of testMimeTypes) {
  89.       // Only query our parsers for MSE-enabled platforms.  Otherwise, query a
  90.       // temporary media element for native support for these types.
  91.       if (shaka.util.Platform.supportsMediaSource()) {
  92.         support[type] = ManifestParser.parsersByMime.has(type);
  93.       } else {
  94.         support[type] = shaka.util.Platform.supportsMediaType(type);
  95.       }
  96.     }
  98.     return support;
  99.   }
  102.   /**
  103.    * Get a factory that can create a manifest parser that should be able to
  104.    * parse the manifest at |uri|.
  105.    *
  106.    * @param {string} uri
  107.    * @param {?string} mimeType
  108.    * @return {shaka.extern.ManifestParser.Factory}
  109.    */
  110.   static getFactory(uri, mimeType) {
  111.     const ManifestParser = shaka.media.ManifestParser;
  113.     // Try using the MIME type we were given.
  114.     if (mimeType) {
  115.       const factory = ManifestParser.parsersByMime.get(mimeType.toLowerCase());
  116.       if (factory) {
  117.         return factory;
  118.       }
  120.       shaka.log.warning(
  121.           'Could not determine manifest type using MIME type ', mimeType);
  122.     }
  124.     throw new shaka.util.Error(
  125.         shaka.util.Error.Severity.CRITICAL,
  126.         shaka.util.Error.Category.MANIFEST,
  127.         shaka.util.Error.Code.UNABLE_TO_GUESS_MANIFEST_TYPE,
  128.         uri,
  129.         mimeType);
  130.   }
  133.   /**
  134.    * Determines whether or not the MIME type is supported by our own
  135.    * manifest parsers on this platform.  This takes into account whether or not
  136.    * MediaSource is available, as well as which parsers are registered to the
  137.    * system.
  138.    *
  139.    * @param {string} mimeType
  140.    * @return {boolean}
  141.    */
  142.   static isSupported(mimeType) {
  143.     // Without MediaSource, our own parsers are useless.
  144.     if (!shaka.util.Platform.supportsMediaSource()) {
  145.       return false;
  146.     }
  148.     return shaka.media.ManifestParser.parsersByMime.has(mimeType);
  149.   }
  150. };
  153. /**
  154.  * @const {string}
  155.  */
  156. shaka.media.ManifestParser.HLS = 'HLS';
  159. /**
  160.  * @const {string}
  161.  */
  162. shaka.media.ManifestParser.DASH = 'DASH';
  165. /**
  166.  * @const {string}
  167.  */
  168. shaka.media.ManifestParser.MSS = 'MSS';
  171. /**
  172.  * @const {string}
  173.  */
  174. shaka.media.ManifestParser.UNKNOWN = 'UNKNOWN';
  177. /**
  178.  * @enum {string}
  179.  * @export
  180.  */
  181. shaka.media.ManifestParser.AccessibilityPurpose = {
  182.   VISUALLY_IMPAIRED: 'visually impaired',
  183.   HARD_OF_HEARING: 'hard of hearing',
  184. };
  187. /**
  188.  * Contains the parser factory functions indexed by MIME type.
  189.  *
  190.  * @type {!Map<string, shaka.extern.ManifestParser.Factory>}
  191.  */
  192. shaka.media.ManifestParser.parsersByMime = new Map();