Source: lib/media/manifest_parser.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.media.ManifestParser');
  20. goog.require('goog.Uri');
  21. goog.require('goog.asserts');
  22. goog.require('shaka.log');
  23. goog.require('shaka.net.NetworkingEngine');
  24. goog.require('shaka.util.Error');
  25. goog.require('shaka.util.Platform');
  28. /**
  29.  * @namespace shaka.media.ManifestParser
  30.  * @summary An interface to register manifest parsers.
  31.  * @exportDoc
  32.  */
  35. /**
  36.  * Contains the parser factory functions indexed by MIME type.
  37.  *
  38.  * @type {!Object.<string, shaka.extern.ManifestParser.Factory>}
  39.  */
  40. shaka.media.ManifestParser.parsersByMime = {};
  43. /**
  44.  * Contains the parser factory functions indexed by file extension.
  45.  *
  46.  * @type {!Object.<string, shaka.extern.ManifestParser.Factory>}
  47.  */
  48. shaka.media.ManifestParser.parsersByExtension = {};
  51. /**
  52.  * Registers a manifest parser by file extension.
  53.  *
  54.  * @param {string} extension The file extension of the manifest.
  55.  * @param {shaka.extern.ManifestParser.Factory} parserFactory The factory
  56.  *   used to create parser instances.
  57.  * @export
  58.  */
  59. shaka.media.ManifestParser.registerParserByExtension = function(
  60.     extension, parserFactory) {
  61.   shaka.media.ManifestParser.parsersByExtension[extension] = parserFactory;
  62. };
  65. /**
  66.  * Registers a manifest parser by MIME type.
  67.  *
  68.  * @param {string} mimeType The MIME type of the manifest.
  69.  * @param {shaka.extern.ManifestParser.Factory} parserFactory The factory
  70.  *   used to create parser instances.
  71.  * @export
  72.  */
  73. shaka.media.ManifestParser.registerParserByMime = function(
  74.     mimeType, parserFactory) {
  75.   shaka.media.ManifestParser.parsersByMime[mimeType] = parserFactory;
  76. };
  79. /**
  80.  * Returns a map of manifest support for well-known types.
  81.  *
  82.  * @return {!Object.<string, boolean>}
  83.  */
  84. shaka.media.ManifestParser.probeSupport = function() {
  85.   const ManifestParser = shaka.media.ManifestParser;
  86.   let support = {};
  88.   // Make sure all registered parsers are shown, but only for MSE-enabled
  89.   // platforms where our parsers matter.
  90.   if (shaka.util.Platform.supportsMediaSource()) {
  91.     for (let type in ManifestParser.parsersByMime) {
  92.       support[type] = true;
  93.     }
  94.     for (let type in ManifestParser.parsersByExtension) {
  95.       support[type] = true;
  96.     }
  97.   }
  99.   // Make sure all well-known types are tested as well, just to show an explicit
  100.   // false for things people might be expecting.
  101.   const testMimeTypes = [
  102.     // DASH
  103.     'application/dash+xml',
  104.     // HLS
  105.     'application/x-mpegurl',
  106.     'application/vnd.apple.mpegurl',
  107.     // SmoothStreaming
  108.     'application/vnd.ms-sstr+xml',
  109.   ];
  110.   const testExtensions = {
  111.     // DASH
  112.     'mpd': 'application/dash+xml',
  113.     // HLS
  114.     'm3u8': 'application/x-mpegurl',
  115.     // SmoothStreaming
  116.     'ism': 'application/vnd.ms-sstr+xml',
  117.   };
  119.   for (let type of testMimeTypes) {
  120.     // Only query our parsers for MSE-enabled platforms.  Otherwise, query a
  121.     // temporary media element for native support for these types.
  122.     if (shaka.util.Platform.supportsMediaSource()) {
  123.       support[type] = !!ManifestParser.parsersByMime[type];
  124.     } else {
  125.       support[type] = shaka.util.Platform.supportsMediaType(type);
  126.     }
  127.   }
  129.   for (let extension in testExtensions) {
  130.     // Only query our parsers for MSE-enabled platforms.  Otherwise, query a
  131.     // temporary media element for native support for these MIME type for the
  132.     // extension.
  133.     if (shaka.util.Platform.supportsMediaSource()) {
  134.       support[extension] = !!ManifestParser.parsersByExtension[extension];
  135.     } else {
  136.       const type = testExtensions[extension];
  137.       support[extension] = shaka.util.Platform.supportsMediaType(type);
  138.     }
  139.   }
  141.   return support;
  142. };
  145. /**
  146.  * Create a manifest parser to parse the manifest at |uri|.
  147.  *
  148.  * @param {string} uri
  149.  * @param {!shaka.net.NetworkingEngine} netEngine
  150.  * @param {shaka.extern.RetryParameters} retryParams
  151.  * @param {?string} mimeType
  152.  * @return {!Promise.<!shaka.extern.ManifestParser>}
  153.  */
  154. shaka.media.ManifestParser.create = async function(
  155.     uri, netEngine, retryParams, mimeType) {
  156.   try {
  157.     const Factory = await shaka.media.ManifestParser.getFactory_(
  158.         uri, netEngine, retryParams, mimeType);
  160.     return new Factory();
  161.   } catch (error) {
  162.     goog.asserts.assert(
  163.         error instanceof shaka.util.Error, 'Incorrect error type');
  165.     // Regardless of what the error was, we need to upgrade it to a critical
  166.     // error. We can't do anything if we can't create a manifest parser.
  167.     error.severity = shaka.util.Error.Severity.CRITICAL;
  169.     throw error;
  170.   }
  171. };
  174. /**
  175.  * Get a factory that can create a manifest parser that should be able to parse
  176.  * the manifest at |uri|.
  177.  *
  178.  * @param {string} uri
  179.  * @param {!shaka.net.NetworkingEngine} netEngine
  180.  * @param {shaka.extern.RetryParameters} retryParams
  181.  * @param {?string} mimeType
  182.  * @return {!Promise.<shaka.extern.ManifestParser.Factory>}
  183.  * @private
  184.  */
  185. shaka.media.ManifestParser.getFactory_ = async function(
  186.     uri, netEngine, retryParams, mimeType) {
  187.   const ManifestParser = shaka.media.ManifestParser;
  189.   // Try using the MIME type we were given.
  190.   if (mimeType) {
  191.     const factory = ManifestParser.parsersByMime[mimeType.toLowerCase()];
  192.     if (factory) {
  193.       return factory;
  194.     }
  196.     shaka.log.warning(
  197.         'Could not determine manifest type using MIME type ', mimeType);
  198.   }
  200.   const extension = ManifestParser.getExtension(uri);
  201.   if (extension) {
  202.     const factory = ManifestParser.parsersByExtension[extension];
  203.     if (factory) {
  204.       return factory;
  205.     }
  207.     shaka.log.warning(
  208.         'Could not determine manifest type for extension ', extension);
  209.   } else {
  210.     shaka.log.warning('Could not find extension for ', uri);
  211.   }
  213.   if (!mimeType) {
  214.     mimeType = await ManifestParser.getMimeType(uri, netEngine, retryParams);
  216.     if (mimeType) {
  217.       const factory = shaka.media.ManifestParser.parsersByMime[mimeType];
  218.       if (factory) {
  219.         return factory;
  220.       }
  222.       shaka.log.warning('Could not determine manifest type using MIME type',
  223.                         mimeType);
  224.     }
  225.   }
  227.   throw new shaka.util.Error(
  228.       shaka.util.Error.Severity.CRITICAL,
  229.       shaka.util.Error.Category.MANIFEST,
  230.       shaka.util.Error.Code.UNABLE_TO_GUESS_MANIFEST_TYPE,
  231.       uri);
  232. };
  235. /**
  236.  * @param {string} uri
  237.  * @param {!shaka.net.NetworkingEngine} netEngine
  238.  * @param {shaka.extern.RetryParameters} retryParams
  239.  * @return {!Promise.<string>}
  240.  */
  241. shaka.media.ManifestParser.getMimeType = async function(
  242.     uri, netEngine, retryParams) {
  243.   const type = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  245.   let request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
  246.   request.method = 'HEAD';
  248.   let response = await netEngine.request(type, request).promise;
  250.   // https://bit.ly/2K9s9kf says this header should always be available,
  251.   // but just to be safe:
  252.   const mimeType = response.headers['content-type'];
  253.   return mimeType ? mimeType.toLowerCase().split(';').shift() : '';
  254. };
  257. /**
  258.  * @param {string} uri
  259.  * @return {string}
  260.  */
  261. shaka.media.ManifestParser.getExtension = function(uri) {
  262.   const uriObj = new goog.Uri(uri);
  263.   const uriPieces = uriObj.getPath().split('/');
  264.   const uriFilename = uriPieces.pop();
  265.   const filenamePieces = uriFilename.split('.');
  267.   // Only one piece means there is no extension.
  268.   if (filenamePieces.length == 1) {
  269.     return '';
  270.   }
  272.   return filenamePieces.pop().toLowerCase();
  273. };
  276. /**
  277.  * Determines whether or not this URI and MIME type are supported by our own
  278.  * manifest parsers on this platform.  This takes into account whether or not
  279.  * MediaSource is available, as well as which parsers are registered to the
  280.  * system.
  281.  *
  282.  * @param {string} uri
  283.  * @param {string} mimeType
  284.  * @return {boolean}
  285.  */
  286. shaka.media.ManifestParser.isSupported = function(uri, mimeType) {
  287.   // Without MediaSource, our own parsers are useless.
  288.   if (!shaka.util.Platform.supportsMediaSource()) {
  289.     return false;
  290.   }
  292.   if (mimeType in shaka.media.ManifestParser.parsersByMime) {
  293.     return true;
  294.   }
  296.   const extension = shaka.media.ManifestParser.getExtension(uri);
  297.   if (extension in shaka.media.ManifestParser.parsersByExtension) {
  298.     return true;
  299.   }
  301.   return false;
  302. };