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('goog.Uri');
  10. goog.require('shaka.log');
  11. goog.require('shaka.net.NetworkingEngine');
  12. goog.require('shaka.util.Error');
  13. goog.require('shaka.util.Platform');
  16. // TODO: revisit this when Closure Compiler supports partially-exported classes.
  17. /**
  18.  * @summary An interface to register manifest parsers.
  19.  * @export
  20.  */
  21. shaka.media.ManifestParser = class {
  22.   /**
  23.    * Registers a manifest parser by file extension.
  24.    *
  25.    * @param {string} extension The file extension of the manifest.
  26.    * @param {shaka.extern.ManifestParser.Factory} parserFactory The factory
  27.    *   used to create parser instances.
  28.    * @export
  29.    */
  30.   static registerParserByExtension(extension, parserFactory) {
  31.     shaka.media.ManifestParser.parsersByExtension[extension] = parserFactory;
  32.   }
  35.   /**
  36.    * Registers a manifest parser by MIME type.
  37.    *
  38.    * @param {string} mimeType The MIME type of the manifest.
  39.    * @param {shaka.extern.ManifestParser.Factory} parserFactory The factory
  40.    *   used to create parser instances.
  41.    * @export
  42.    */
  43.   static registerParserByMime(mimeType, parserFactory) {
  44.     shaka.media.ManifestParser.parsersByMime[mimeType] = parserFactory;
  45.   }
  47.   /**
  48.    * Unregisters a manifest parser by MIME type.
  49.    *
  50.    * @param {string} mimeType The MIME type of the manifest.
  51.    * @export
  52.    */
  53.   static unregisterParserByMime(mimeType) {
  54.     delete shaka.media.ManifestParser.parsersByMime[mimeType];
  55.   }
  58.   /**
  59.    * Returns a map of manifest support for well-known types.
  60.    *
  61.    * @return {!Object.<string, boolean>}
  62.    */
  63.   static probeSupport() {
  64.     const ManifestParser = shaka.media.ManifestParser;
  65.     const support = {};
  67.     // Make sure all registered parsers are shown, but only for MSE-enabled
  68.     // platforms where our parsers matter.
  69.     if (shaka.util.Platform.supportsMediaSource()) {
  70.       for (const type in ManifestParser.parsersByMime) {
  71.         support[type] = true;
  72.       }
  73.       for (const type in ManifestParser.parsersByExtension) {
  74.         support[type] = true;
  75.       }
  76.     }
  78.     // Make sure all well-known types are tested as well, just to show an
  79.     // explicit false for things people might be expecting.
  80.     const testMimeTypes = [
  81.       // DASH
  82.       'application/dash+xml',
  83.       // HLS
  84.       'application/x-mpegurl',
  85.       'application/vnd.apple.mpegurl',
  86.       // SmoothStreaming
  87.       'application/vnd.ms-sstr+xml',
  88.     ];
  89.     const testExtensions = {
  90.       // DASH
  91.       'mpd': 'application/dash+xml',
  92.       // HLS
  93.       'm3u8': 'application/x-mpegurl',
  94.       // SmoothStreaming
  95.       'ism': 'application/vnd.ms-sstr+xml',
  96.     };
  98.     for (const type of testMimeTypes) {
  99.       // Only query our parsers for MSE-enabled platforms.  Otherwise, query a
  100.       // temporary media element for native support for these types.
  101.       if (shaka.util.Platform.supportsMediaSource()) {
  102.         support[type] = !!ManifestParser.parsersByMime[type];
  103.       } else {
  104.         support[type] = shaka.util.Platform.supportsMediaType(type);
  105.       }
  106.     }
  108.     for (const extension in testExtensions) {
  109.       // Only query our parsers for MSE-enabled platforms.  Otherwise, query a
  110.       // temporary media element for native support for these MIME type for the
  111.       // extension.
  112.       if (shaka.util.Platform.supportsMediaSource()) {
  113.         support[extension] = !!ManifestParser.parsersByExtension[extension];
  114.       } else {
  115.         const type = testExtensions[extension];
  116.         support[extension] = shaka.util.Platform.supportsMediaType(type);
  117.       }
  118.     }
  120.     return support;
  121.   }
  124.   /**
  125.    * Get a factory that can create a manifest parser that should be able to
  126.    * parse the manifest at |uri|.
  127.    *
  128.    * @param {string} uri
  129.    * @param {!shaka.net.NetworkingEngine} netEngine
  130.    * @param {shaka.extern.RetryParameters} retryParams
  131.    * @param {?string} mimeType
  132.    * @return {!Promise.<shaka.extern.ManifestParser.Factory>}
  133.    */
  134.   static async getFactory(uri, netEngine, retryParams, mimeType) {
  135.     const ManifestParser = shaka.media.ManifestParser;
  137.     // Try using the MIME type we were given.
  138.     if (mimeType) {
  139.       const factory = ManifestParser.parsersByMime[mimeType.toLowerCase()];
  140.       if (factory) {
  141.         return factory;
  142.       }
  144.       shaka.log.warning(
  145.           'Could not determine manifest type using MIME type ', mimeType);
  146.     }
  148.     const extension = ManifestParser.getExtension(uri);
  149.     if (extension) {
  150.       const factory = ManifestParser.parsersByExtension[extension];
  151.       if (factory) {
  152.         return factory;
  153.       }
  155.       shaka.log.warning(
  156.           'Could not determine manifest type for extension ', extension);
  157.     } else {
  158.       shaka.log.warning('Could not find extension for ', uri);
  159.     }
  161.     if (!mimeType) {
  162.       mimeType = await ManifestParser.getMimeType(uri, netEngine, retryParams);
  164.       if (mimeType) {
  165.         const factory = shaka.media.ManifestParser.parsersByMime[mimeType];
  166.         if (factory) {
  167.           return factory;
  168.         }
  170.         shaka.log.warning('Could not determine manifest type using MIME type',
  171.             mimeType);
  172.       }
  173.     }
  175.     throw new shaka.util.Error(
  176.         shaka.util.Error.Severity.CRITICAL,
  177.         shaka.util.Error.Category.MANIFEST,
  178.         shaka.util.Error.Code.UNABLE_TO_GUESS_MANIFEST_TYPE,
  179.         uri,
  180.         mimeType);
  181.   }
  184.   /**
  185.    * @param {string} uri
  186.    * @param {!shaka.net.NetworkingEngine} netEngine
  187.    * @param {shaka.extern.RetryParameters} retryParams
  188.    * @return {!Promise.<string>}
  189.    */
  190.   static async getMimeType(uri, netEngine, retryParams) {
  191.     const type = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  193.     const request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
  194.     request.method = 'HEAD';
  196.     const response = await netEngine.request(type, request).promise;
  198.     // https://bit.ly/2K9s9kf says this header should always be available,
  199.     // but just to be safe:
  200.     const mimeType = response.headers['content-type'];
  201.     return mimeType ? mimeType.toLowerCase().split(';').shift() : '';
  202.   }
  205.   /**
  206.    * @param {string} uri
  207.    * @return {string}
  208.    */
  209.   static getExtension(uri) {
  210.     const uriObj = new goog.Uri(uri);
  211.     const uriPieces = uriObj.getPath().split('/');
  212.     const uriFilename = uriPieces.pop();
  213.     const filenamePieces = uriFilename.split('.');
  215.     // Only one piece means there is no extension.
  216.     if (filenamePieces.length == 1) {
  217.       return '';
  218.     }
  220.     return filenamePieces.pop().toLowerCase();
  221.   }
  224.   /**
  225.    * Determines whether or not this URI and MIME type are supported by our own
  226.    * manifest parsers on this platform.  This takes into account whether or not
  227.    * MediaSource is available, as well as which parsers are registered to the
  228.    * system.
  229.    *
  230.    * @param {string} uri
  231.    * @param {string} mimeType
  232.    * @return {boolean}
  233.    */
  234.   static isSupported(uri, mimeType) {
  235.     // Without MediaSource, our own parsers are useless.
  236.     if (!shaka.util.Platform.supportsMediaSource()) {
  237.       return false;
  238.     }
  240.     if (mimeType in shaka.media.ManifestParser.parsersByMime) {
  241.       return true;
  242.     }
  244.     const extension = shaka.media.ManifestParser.getExtension(uri);
  245.     if (extension in shaka.media.ManifestParser.parsersByExtension) {
  246.       return true;
  247.     }
  249.     return false;
  250.   }
  251. };
  254. /**
  255.  * Contains the parser factory functions indexed by MIME type.
  256.  *
  257.  * @type {!Object.<string, shaka.extern.ManifestParser.Factory>}
  258.  */
  259. shaka.media.ManifestParser.parsersByMime = {};
  262. /**
  263.  * Contains the parser factory functions indexed by file extension.
  264.  *
  265.  * @type {!Object.<string, shaka.extern.ManifestParser.Factory>}
  266.  */
  267. shaka.media.ManifestParser.parsersByExtension = {};