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.transmuxer.TransmuxerEngine');
  10. goog.require('shaka.util.ManifestParserUtils');
  12. /**
  13.  * @summary A set of utility functions for dealing with MIME types.
  14.  * @export
  15.  */
  16. shaka.util.MimeUtils = class {
  17.   /**
  18.    * Takes a MIME type and optional codecs string and produces the full MIME
  19.    * type. Also remove the codecs for raw formats.
  20.    *
  21.    * @param {string} mimeType
  22.    * @param {string=} codecs
  23.    * @return {string}
  24.    * @export
  25.    */
  26.   static getFullType(mimeType, codecs) {
  27.     let fullMimeType = mimeType;
  28.     if (codecs && !shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType)) {
  29.       fullMimeType += '; codecs="' + codecs + '"';
  30.     }
  31.     return fullMimeType;
  32.   }
  34.   /**
  35.    * Takes a MIME type and optional codecs string and produces the full MIME
  36.    * type.
  37.    *
  38.    * @param {string} mimeType
  39.    * @param {string=} codecs
  40.    * @return {string}
  41.    * @export
  42.    */
  43.   static getFullTypeWithAllCodecs(mimeType, codecs) {
  44.     let fullMimeType = mimeType;
  45.     if (codecs) {
  46.       fullMimeType += '; codecs="' + codecs + '"';
  47.     }
  48.     return fullMimeType;
  49.   }
  51.   /**
  52.    * Takes a MIME type and a codecs string and produces the full MIME
  53.    * type. If it's a transport stream, convert its codecs to MP4 codecs.
  54.    * Otherwise for multiplexed content, convert the video MIME types to
  55.    * their audio equivalents if the content type is audio.
  56.    *
  57.    * @param {string} mimeType
  58.    * @param {string} codecs
  59.    * @param {string} contentType
  60.    * @return {string}
  61.    */
  62.   static getFullOrConvertedType(mimeType, codecs, contentType) {
  63.     const MimeUtils = shaka.util.MimeUtils;
  64.     const fullMimeType = MimeUtils.getFullType(mimeType, codecs);
  65.     const fullMimeTypeWithAllCodecs = MimeUtils.getFullTypeWithAllCodecs(
  66.         mimeType, codecs);
  67.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  68.     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
  70.     if (TransmuxerEngine.isSupported(fullMimeTypeWithAllCodecs, contentType)) {
  71.       return TransmuxerEngine.convertCodecs(
  72.           contentType, fullMimeTypeWithAllCodecs);
  73.     } else if (mimeType != 'video/mp2t' && contentType == ContentType.AUDIO) {
  74.       // video/mp2t is the correct mime type for TS audio, so only replace the
  75.       // word "video" with "audio" for non-TS audio content.
  76.       return fullMimeType.replace('video', 'audio');
  77.     }
  78.     return fullMimeType;
  79.   }
  82.   /**
  83.    * Takes a Stream object and produces an extended MIME type with information
  84.    * beyond the container and codec type, when available.
  85.    *
  86.    * @param {shaka.extern.Stream} stream
  87.    * @param {string} mimeType
  88.    * @param {string} codecs
  89.    * @return {string}
  90.    */
  91.   static getExtendedType(stream, mimeType, codecs) {
  92.     const components = [mimeType];
  94.     const extendedMimeParams = shaka.util.MimeUtils.EXTENDED_MIME_PARAMETERS_;
  95.     extendedMimeParams.forEach((mimeKey, streamKey) => {
  96.       const value = stream[streamKey];
  97.       if (streamKey == 'codecs') {
  98.         if (shaka.util.MimeUtils.RAW_FORMATS.includes(stream.mimeType)) {
  99.           // Skip codecs for raw formats
  100.         } else {
  101.           components.push('codecs="' + codecs + '"');
  102.         }
  103.       } else if (value) {
  104.         components.push(mimeKey + '="' + value + '"');
  105.       }
  106.     });
  107.     if (stream.hdr == 'PQ') {
  108.       components.push('eotf="smpte2084"');
  109.     }
  111.     return components.join(';');
  112.   }
  114.   /**
  115.    * Takes a full MIME type (with codecs) or basic MIME type (without codecs)
  116.    * and returns a container type string ("mp2t", "mp4", "webm", etc.)
  117.    *
  118.    * @param {string} mimeType
  119.    * @return {string}
  120.    */
  121.   static getContainerType(mimeType) {
  122.     return mimeType.split(';')[0].split('/')[1];
  123.   }
  125.   /**
  126.    * Split a list of codecs encoded in a string into a list of codecs.
  127.    * @param {string} codecs
  128.    * @return {!Array<string>}
  129.    */
  130.   static splitCodecs(codecs) {
  131.     return codecs.split(',');
  132.   }
  134.   /**
  135.    * Get the normalized codec from a codec string,
  136.    * independently of their container.
  137.    *
  138.    * @param {string} codecString
  139.    * @return {string}
  140.    */
  141.   static getNormalizedCodec(codecString) {
  142.     const parts =
  143.       shaka.util.MimeUtils.getCodecParts_(codecString);
  144.     const base = parts[0].toLowerCase();
  145.     const profile = parts[1].toLowerCase();
  146.     switch (true) {
  147.       case base === 'mp4a' && profile === '69':
  148.       case base === 'mp4a' && profile === '6b':
  149.       case base === 'mp4a' && profile === '40.34':
  150.         return 'mp3';
  151.       case base === 'mp4a' && profile === '66':
  152.       case base === 'mp4a' && profile === '67':
  153.       case base === 'mp4a' && profile === '68':
  154.       case base === 'mp4a' && profile === '40.2':
  155.       case base === 'mp4a' && profile === '40.02':
  156.       case base === 'mp4a' && profile === '40.5':
  157.       case base === 'mp4a' && profile === '40.05':
  158.       case base === 'mp4a' && profile === '40.29':
  159.       case base === 'mp4a' && profile === '40.42': // Extended HE-AAC
  160.         return 'aac';
  161.       case base === 'mp4a' && profile === 'a5':
  162.       case base === 'ac3':
  163.       case base === 'ac-3':
  164.         return 'ac-3'; // Dolby Digital
  165.       case base === 'mp4a' && profile === 'a6':
  166.       case base === 'eac3':
  167.       case base === 'ec-3':
  168.         return 'ec-3'; // Dolby Digital Plus
  169.       case base === 'ac-4':
  170.         return 'ac-4'; // Dolby AC-4
  171.       case base === 'mp4a' && profile === 'b2':
  172.         return 'dtsx'; // DTS:X
  173.       case base === 'mp4a' && profile === 'a9':
  174.         return 'dtsc'; // DTS Digital Surround
  175.       case base === 'vp09':
  176.       case base === 'vp9':
  177.         return 'vp9';
  178.       case base === 'avc1':
  179.       case base === 'avc3':
  180.         return 'avc'; // H264
  181.       case base === 'hvc1':
  182.       case base === 'hev1':
  183.         return 'hevc'; // H265
  184.       case base === 'vvc1':
  185.       case base === 'vvi1':
  186.         return 'vvc'; // H266
  187.       case base === 'dvh1':
  188.       case base === 'dvhe':
  189.         if (profile && profile.startsWith('05')) {
  190.           return 'dovi-p5'; // Dolby Vision profile 5
  191.         }
  192.         return 'dovi-hevc'; // Dolby Vision based in HEVC
  193.       case base === 'dvav':
  194.       case base === 'dva1':
  195.         return 'dovi-avc'; // Dolby Vision based in AVC
  196.       case base === 'dav1':
  197.         return 'dovi-av1'; // Dolby Vision based in AV1
  198.       case base === 'dvc1':
  199.       case base === 'dvi1':
  200.         return 'dovi-vvc'; // Dolby Vision based in VVC
  201.     }
  202.     return base;
  203.   }
  205.   /**
  206.    * Get the base codec from a codec string.
  207.    *
  208.    * @param {string} codecString
  209.    * @return {string}
  210.    */
  211.   static getCodecBase(codecString) {
  212.     const codecsBase = [];
  213.     for (const codec of codecString.split(',')) {
  214.       const parts = shaka.util.MimeUtils.getCodecParts_(codec);
  215.       codecsBase.push(parts[0]);
  216.     }
  217.     return codecsBase.sort().join(',');
  218.   }
  220.   /**
  221.    * Takes a full MIME type (with codecs) or basic MIME type (without codecs)
  222.    * and returns a basic MIME type (without codecs or other parameters).
  223.    *
  224.    * @param {string} mimeType
  225.    * @return {string}
  226.    */
  227.   static getBasicType(mimeType) {
  228.     return mimeType.split(';')[0];
  229.   }
  231.   /**
  232.    * Takes a MIME type and returns the codecs parameter, or an empty string if
  233.    * there is no codecs parameter.
  234.    *
  235.    * @param {string} mimeType
  236.    * @return {string}
  237.    */
  238.   static getCodecs(mimeType) {
  239.     // Parse the basic MIME type from its parameters.
  240.     const pieces = mimeType.split(/ *; */);
  241.     pieces.shift();  // Remove basic MIME type from pieces.
  243.     const codecs = pieces.find((piece) => piece.startsWith('codecs='));
  244.     if (!codecs) {
  245.       return '';
  246.     }
  248.     // The value may be quoted, so remove quotes at the beginning or end.
  249.     const value = codecs.split('=')[1].replace(/^"|"$/g, '');
  250.     return value;
  251.   }
  253.   /**
  254.    * Checks if the given MIME type is HLS MIME type.
  255.    *
  256.    * @param {string} mimeType
  257.    * @return {boolean}
  258.    */
  259.   static isHlsType(mimeType) {
  260.     return mimeType === 'application/x-mpegurl' ||
  261.         mimeType === 'application/vnd.apple.mpegurl';
  262.   }
  264.   /**
  265.    * Checks if the given MIME type is DASH MIME type.
  266.    *
  267.    * @param {string} mimeType
  268.    * @return {boolean}
  269.    */
  270.   static isDashType(mimeType) {
  271.     return mimeType === 'application/dash+xml' ||
  272.         mimeType === 'video/vnd.mpeg.dash.mpd';
  273.   }
  275.   /**
  276.    * Get the base and profile of a codec string. Where [0] will be the codec
  277.    * base and [1] will be the profile.
  278.    * @param {string} codecString
  279.    * @return {!Array<string>}
  280.    * @private
  281.    */
  282.   static getCodecParts_(codecString) {
  283.     const parts = codecString.split('.');
  285.     const base = parts[0];
  287.     parts.shift();
  288.     const profile = parts.join('.');
  290.     // Make sure that we always return a "base" and "profile".
  291.     return [base, profile];
  292.   }
  293. };
  296. /**
  297.  * A map from Stream object keys to MIME type parameters.  These should be
  298.  * ignored by platforms that do not recognize them.
  299.  *
  300.  * This initial set of parameters are all recognized by Chromecast.
  301.  *
  302.  * @const {!Map<string, string>}
  303.  * @private
  304.  */
  305. shaka.util.MimeUtils.EXTENDED_MIME_PARAMETERS_ = new Map()
  306.     .set('codecs', 'codecs')
  307.     .set('frameRate', 'framerate')  // Ours is camelCase, theirs is lowercase.
  308.     .set('bandwidth', 'bitrate')  // They are in the same units: bits/sec.
  309.     .set('width', 'width')
  310.     .set('height', 'height')
  311.     .set('channelsCount', 'channels');
  314. /**
  315.  * A mimetype created for CEA-608 closed captions.
  316.  * @const {string}
  317.  */
  318. shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE = 'application/cea-608';
  320. /**
  321.  * A mimetype created for CEA-708 closed captions.
  322.  * @const {string}
  323.  */
  324. shaka.util.MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE = 'application/cea-708';
  326. /**
  327.  * MIME types of raw formats.
  328.  *
  329.  * @const {!Array<string>}
  330.  */
  331. shaka.util.MimeUtils.RAW_FORMATS = [
  332.   'audio/aac',
  333.   'audio/ac3',
  334.   'audio/ec3',
  335.   'audio/mpeg',
  336. ];