Source: lib/util/mime_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.MimeUtils');
  9. goog.require('shaka.dependencies');
  10. goog.require('shaka.media.Transmuxer');
  11. goog.require('shaka.util.ManifestParserUtils');
  13. /**
  14.  * @summary A set of utility functions for dealing with MIME types.
  15.  * @export
  16.  */
  17. shaka.util.MimeUtils = class {
  18.   /**
  19.    * Takes a MIME type and optional codecs string and produces the full MIME
  20.    * type.
  21.    *
  22.    * @param {string} mimeType
  23.    * @param {string=} codecs
  24.    * @return {string}
  25.    * @export
  26.    */
  27.   static getFullType(mimeType, codecs) {
  28.     let fullMimeType = mimeType;
  29.     if (codecs) {
  30.       fullMimeType += '; codecs="' + codecs + '"';
  31.     }
  32.     return fullMimeType;
  33.   }
  35.   /**
  36.    * Takes a MIME type and a codecs string and produces the full MIME
  37.    * type. If it's a transport stream, convert its codecs to MP4 codecs.
  38.    * Otherwise for multiplexed content, convert the video MIME types to
  39.    * their audio equivalents if the content type is audio.
  40.    *
  41.    * @param {string} mimeType
  42.    * @param {string} codecs
  43.    * @param {string} contentType
  44.    * @return {string}
  45.    */
  46.   static getFullOrConvertedType(mimeType, codecs, contentType) {
  47.     const fullMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
  48.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  50.     if (shaka.media.Transmuxer.isTsContainer(fullMimeType)) {
  51.       if (shaka.dependencies.muxjs()) {
  52.         return shaka.media.Transmuxer.convertTsCodecs(
  53.             contentType, fullMimeType);
  54.       }
  55.     } else if (contentType == ContentType.AUDIO) {
  56.       // video/mp2t is the correct mime type for TS audio, so only replace the
  57.       // word "video" with "audio" for non-TS audio content.
  58.       return fullMimeType.replace('video', 'audio');
  59.     }
  60.     return fullMimeType;
  61.   }
  64.   /**
  65.    * Takes a Stream object and produces an extended MIME type with information
  66.    * beyond the container and codec type, when available.
  67.    *
  68.    * @param {shaka.extern.Stream} stream
  69.    * @return {string}
  70.    */
  71.   static getExtendedType(stream) {
  72.     const components = [stream.mimeType];
  74.     const extendedMimeParams = shaka.util.MimeUtils.EXTENDED_MIME_PARAMETERS_;
  75.     extendedMimeParams.forEach((mimeKey, streamKey) => {
  76.       const value = stream[streamKey];
  77.       if (value) {
  78.         components.push(mimeKey + '="' + value + '"');
  79.       }
  80.     });
  81.     if (stream.hdr == 'PQ') {
  82.       components.push('eotf="smpte2084"');
  83.     }
  85.     return components.join(';');
  86.   }
  88.   /**
  89.    * Takes a full MIME type (with codecs) or basic MIME type (without codecs)
  90.    * and returns a container type string ("mp2t", "mp4", "webm", etc.)
  91.    *
  92.    * @param {string} mimeType
  93.    * @return {string}
  94.    */
  95.   static getContainerType(mimeType) {
  96.     return mimeType.split(';')[0].split('/')[1];
  97.   }
  99.   /**
  100.    * Split a list of codecs encoded in a string into a list of codecs.
  101.    * @param {string} codecs
  102.    * @return {!Array.<string>}
  103.    */
  104.   static splitCodecs(codecs) {
  105.     return codecs.split(',');
  106.   }
  108.   /**
  109.    * Get the normalized codec from a codec string,
  110.    * independently of their container.
  111.    *
  112.    * @param {string} codecString
  113.    * @return {string}
  114.    */
  115.   static getNormalizedCodec(codecString) {
  116.     const parts =
  117.       shaka.util.MimeUtils.getCodecParts_(codecString);
  118.     const base = parts[0];
  119.     const profile = parts[1].toLowerCase();
  120.     switch (true) {
  121.       case base === 'mp4a' && profile === '69':
  122.       case base === 'mp4a' && profile === '6b':
  123.         return 'mp3';
  124.       case base === 'mp4a' && profile === '66':
  125.       case base === 'mp4a' && profile === '67':
  126.       case base === 'mp4a' && profile === '68':
  127.       case base === 'mp4a' && profile === '40.2':
  128.       case base === 'mp4a' && profile === '40.02':
  129.       case base === 'mp4a' && profile === '40.5':
  130.       case base === 'mp4a' && profile === '40.05':
  131.       case base === 'mp4a' && profile === '40.29':
  132.       case base === 'mp4a' && profile === '40.42': // Extended HE-AAC
  133.         return 'aac';
  134.       case base === 'mp4a' && profile === 'a5':
  135.         return 'ac-3'; // Dolby Digital
  136.       case base === 'mp4a' && profile === 'a6':
  137.         return 'ec-3'; // Dolby Digital Plus
  138.       case base === 'mp4a' && profile === 'b2':
  139.         return 'dtsx'; // DTS:X
  140.       case base === 'mp4a' && profile === 'a9':
  141.         return 'dtsc'; // DTS Digital Surround
  142.       case base === 'avc1':
  143.       case base === 'avc3':
  144.         return 'avc'; // H264
  145.       case base === 'hvc1':
  146.       case base === 'hev1':
  147.         return 'hevc'; // H265
  148.       case base === 'dvh1':
  149.       case base === 'dvhe':
  150.         return 'dovi'; // Dolby Vision
  151.     }
  152.     return base;
  153.   }
  155.   /**
  156.    * Get the base codec from a codec string.
  157.    *
  158.    * @param {string} codecString
  159.    * @return {string}
  160.    */
  161.   static getCodecBase(codecString) {
  162.     const parts = shaka.util.MimeUtils.getCodecParts_(codecString);
  163.     return parts[0];
  164.   }
  166.   /**
  167.    * Takes a full MIME type (with codecs) or basic MIME type (without codecs)
  168.    * and returns a basic MIME type (without codecs or other parameters).
  169.    *
  170.    * @param {string} mimeType
  171.    * @return {string}
  172.    */
  173.   static getBasicType(mimeType) {
  174.     return mimeType.split(';')[0];
  175.   }
  177.   /**
  178.    * Takes a MIME type and returns the codecs parameter, or an empty string if
  179.    * there is no codecs parameter.
  180.    *
  181.    * @param {string} mimeType
  182.    * @return {string}
  183.    */
  184.   static getCodecs(mimeType) {
  185.     // Parse the basic MIME type from its parameters.
  186.     const pieces = mimeType.split(/ *; */);
  187.     pieces.shift();  // Remove basic MIME type from pieces.
  189.     const codecs = pieces.find((piece) => piece.startsWith('codecs='));
  190.     if (!codecs) {
  191.       return '';
  192.     }
  194.     // The value may be quoted, so remove quotes at the beginning or end.
  195.     const value = codecs.split('=')[1].replace(/^"|"$/g, '');
  196.     return value;
  197.   }
  199.   /**
  200.    * Get the base and profile of a codec string. Where [0] will be the codec
  201.    * base and [1] will be the profile.
  202.    * @param {string} codecString
  203.    * @return {!Array.<string>}
  204.    * @private
  205.    */
  206.   static getCodecParts_(codecString) {
  207.     const parts = codecString.split('.');
  209.     const base = parts[0];
  211.     parts.shift();
  212.     const profile = parts.join('.');
  214.     // Make sure that we always return a "base" and "profile".
  215.     return [base, profile];
  216.   }
  217. };
  220. /**
  221.  * A map from Stream object keys to MIME type parameters.  These should be
  222.  * ignored by platforms that do not recognize them.
  223.  *
  224.  * This initial set of parameters are all recognized by Chromecast.
  225.  *
  226.  * @const {!Map.<string, string>}
  227.  * @private
  228.  */
  229. shaka.util.MimeUtils.EXTENDED_MIME_PARAMETERS_ = new Map()
  230.     .set('codecs', 'codecs')
  231.     .set('frameRate', 'framerate')  // Ours is camelCase, theirs is lowercase.
  232.     .set('bandwidth', 'bitrate')  // They are in the same units: bits/sec.
  233.     .set('width', 'width')
  234.     .set('height', 'height')
  235.     .set('channelsCount', 'channels');
  238. /**
  239.  * A mimetype created for CEA-608 closed captions.
  240.  * @const {string}
  241.  */
  242. shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE = 'application/cea-608';
  244. /**
  245.  * A mimetype created for CEA-708 closed captions.
  246.  * @const {string}
  247.  */
  248. shaka.util.MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE = 'application/cea-708';