Source: lib/media/segment_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.SegmentUtils');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.media.ClosedCaptionParser');
  12. goog.require('shaka.util.BufferUtils');
  13. goog.require('shaka.util.MimeUtils');
  14. goog.require('shaka.util.Mp4BoxParsers');
  15. goog.require('shaka.util.Mp4Parser');
  16. goog.require('shaka.util.TsParser');
  19. /**
  20.  * @summary Utility functions for segment parsing.
  21.  */
  22. shaka.media.SegmentUtils = class {
  23.   /**
  24.    * @param {string} mimeType
  25.    * @return {shaka.media.SegmentUtils.BasicInfo}
  26.    */
  27.   static getBasicInfoFromMimeType(mimeType) {
  28.     const baseMimeType = shaka.util.MimeUtils.getBasicType(mimeType);
  29.     const type = baseMimeType.split('/')[0];
  30.     const codecs = shaka.util.MimeUtils.getCodecs(mimeType);
  31.     return {
  32.       type: type,
  33.       mimeType: baseMimeType,
  34.       codecs: codecs,
  35.       language: null,
  36.       height: null,
  37.       width: null,
  38.       channelCount: null,
  39.       sampleRate: null,
  40.       closedCaptions: new Map(),
  41.     };
  42.   }
  44.   /**
  45.    * @param {!BufferSource} data
  46.    * @return {?shaka.media.SegmentUtils.BasicInfo}
  47.    */
  48.   static getBasicInfoFromTs(data) {
  49.     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
  50.     const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
  51.     const tsCodecs = tsParser.getCodecs();
  52.     const videoInfo = tsParser.getVideoInfo();
  53.     const codecs = [];
  54.     let hasAudio = false;
  55.     let hasVideo = false;
  56.     switch (tsCodecs.audio) {
  57.       case 'aac':
  58.       case 'aac-loas':
  59.         codecs.push('mp4a.40.2');
  60.         hasAudio = true;
  61.         break;
  62.       case 'mp3':
  63.         codecs.push('mp4a.40.34');
  64.         hasAudio = true;
  65.         break;
  66.       case 'ac3':
  67.         codecs.push('ac-3');
  68.         hasAudio = true;
  69.         break;
  70.       case 'ec3':
  71.         codecs.push('ec-3');
  72.         hasAudio = true;
  73.         break;
  74.       case 'opus':
  75.         codecs.push('opus');
  76.         hasAudio = true;
  77.         break;
  78.     }
  79.     switch (tsCodecs.video) {
  80.       case 'avc':
  81.         if (videoInfo.codec) {
  82.           codecs.push(videoInfo.codec);
  83.         } else {
  84.           codecs.push('avc1.42E01E');
  85.         }
  86.         hasVideo = true;
  87.         break;
  88.       case 'hvc':
  89.         if (videoInfo.codec) {
  90.           codecs.push(videoInfo.codec);
  91.         } else {
  92.           codecs.push('hvc1.1.6.L93.90');
  93.         }
  94.         hasVideo = true;
  95.         break;
  96.       case 'av1':
  97.         codecs.push('av01.0.01M.08');
  98.         hasVideo = true;
  99.         break;
  100.     }
  101.     if (!codecs.length) {
  102.       return null;
  103.     }
  104.     const onlyAudio = hasAudio && !hasVideo;
  105.     const closedCaptions = new Map();
  106.     if (hasVideo) {
  107.       const captionParser = new shaka.media.ClosedCaptionParser('video/mp2t');
  108.       captionParser.parseFrom(data);
  109.       for (const stream of captionParser.getStreams()) {
  110.         closedCaptions.set(stream, stream);
  111.       }
  112.       captionParser.reset();
  113.     }
  114.     return {
  115.       type: onlyAudio ? 'audio' : 'video',
  116.       mimeType: 'video/mp2t',
  117.       codecs: codecs.join(', '),
  118.       language: null,
  119.       height: videoInfo.height,
  120.       width: videoInfo.width,
  121.       channelCount: null,
  122.       sampleRate: null,
  123.       closedCaptions: closedCaptions,
  124.     };
  125.   }
  127.   /**
  128.    * @param {?BufferSource} initData
  129.    * @param {!BufferSource} data
  130.    * @return {?shaka.media.SegmentUtils.BasicInfo}
  131.    */
  132.   static getBasicInfoFromMp4(initData, data) {
  133.     const Mp4Parser = shaka.util.Mp4Parser;
  134.     const SegmentUtils = shaka.media.SegmentUtils;
  136.     const codecs = [];
  138.     let hasAudio = false;
  139.     let hasVideo = false;
  141.     const addCodec = (codec) => {
  142.       const codecLC = codec.toLowerCase();
  143.       switch (codecLC) {
  144.         case 'avc1':
  145.         case 'avc3':
  146.           codecs.push(codecLC + '.42E01E');
  147.           hasVideo = true;
  148.           break;
  149.         case 'hev1':
  150.         case 'hvc1':
  151.           codecs.push(codecLC + '.1.6.L93.90');
  152.           hasVideo = true;
  153.           break;
  154.         case 'dvh1':
  155.         case 'dvhe':
  156.           codecs.push(codecLC + '.05.04');
  157.           hasVideo = true;
  158.           break;
  159.         case 'vp09':
  160.           codecs.push(codecLC + '.00.10.08');
  161.           hasVideo = true;
  162.           break;
  163.         case 'av01':
  164.           codecs.push(codecLC + '.0.01M.08');
  165.           hasVideo = true;
  166.           break;
  167.         case 'mp4a':
  168.           // We assume AAC, but this can be wrong since mp4a supports
  169.           // others codecs
  170.           codecs.push('mp4a.40.2');
  171.           hasAudio = true;
  172.           break;
  173.         case 'ac-3':
  174.         case 'ec-3':
  175.         case 'opus':
  176.         case 'flac':
  177.           codecs.push(codecLC);
  178.           hasAudio = true;
  179.           break;
  180.       }
  181.     };
  183.     const codecBoxParser = (box) => addCodec(box.name);
  185.     /** @type {?string} */
  186.     let language = null;
  187.     /** @type {?string} */
  188.     let height = null;
  189.     /** @type {?string} */
  190.     let width = null;
  191.     /** @type {?number} */
  192.     let channelCount = null;
  193.     /** @type {?number} */
  194.     let sampleRate = null;
  196.     new Mp4Parser()
  197.         .box('moov', Mp4Parser.children)
  198.         .box('trak', Mp4Parser.children)
  199.         .fullBox('tkhd', (box) => {
  200.           goog.asserts.assert(
  201.               box.version != null,
  202.               'TKHD is a full box and should have a valid version.');
  203.           const parsedTKHDBox = shaka.util.Mp4BoxParsers.parseTKHD(
  204.               box.reader, box.version);
  205.           height = String(parsedTKHDBox.height);
  206.           width = String(parsedTKHDBox.width);
  207.         })
  208.         .box('mdia', Mp4Parser.children)
  209.         .fullBox('mdhd', (box) => {
  210.           goog.asserts.assert(
  211.               box.version != null,
  212.               'MDHD is a full box and should have a valid version.');
  213.           const parsedMDHDBox = shaka.util.Mp4BoxParsers.parseMDHD(
  214.               box.reader, box.version);
  215.           language = parsedMDHDBox.language;
  216.         })
  217.         .box('minf', Mp4Parser.children)
  218.         .box('stbl', Mp4Parser.children)
  219.         .fullBox('stsd', Mp4Parser.sampleDescription)
  221.         // AUDIO
  222.         // These are the various boxes that signal a codec.
  223.         .box('mp4a', (box) => {
  224.           const parsedMP4ABox = shaka.util.Mp4BoxParsers.parseMP4A(box.reader);
  225.           channelCount = parsedMP4ABox.channelCount;
  226.           sampleRate = parsedMP4ABox.sampleRate;
  227.           if (box.reader.hasMoreData()) {
  228.             Mp4Parser.children(box);
  229.           } else {
  230.             codecBoxParser(box);
  231.           }
  232.         })
  233.         .box('esds', (box) => {
  234.           const parsedESDSBox = shaka.util.Mp4BoxParsers.parseESDS(box.reader);
  235.           codecs.push(parsedESDSBox.codec);
  236.           hasAudio = true;
  237.         })
  238.         .box('ac-3', codecBoxParser)
  239.         .box('ec-3', codecBoxParser)
  240.         .box('opus', codecBoxParser)
  241.         .box('Opus', codecBoxParser)
  242.         .box('fLaC', codecBoxParser)
  244.         // VIDEO
  245.         // These are the various boxes that signal a codec.
  246.         .box('avc1', (box) => {
  247.           const parsedAVCBox =
  248.               shaka.util.Mp4BoxParsers.parseAVC(box.reader, box.name);
  249.           codecs.push(parsedAVCBox.codec);
  250.           hasVideo = true;
  251.         })
  252.         .box('avc3', (box) => {
  253.           const parsedAVCBox =
  254.               shaka.util.Mp4BoxParsers.parseAVC(box.reader, box.name);
  255.           codecs.push(parsedAVCBox.codec);
  256.           hasVideo = true;
  257.         })
  258.         .box('hev1', codecBoxParser)
  259.         .box('hvc1', codecBoxParser)
  260.         .box('dvh1', codecBoxParser)
  261.         .box('dvhe', codecBoxParser)
  262.         .box('vp09', codecBoxParser)
  263.         .box('av01', codecBoxParser)
  265.         // This signals an encrypted sample, which we can go inside of to
  266.         // find the codec used.
  267.         // Note: If encrypted, you can only have audio or video, not both.
  268.         .box('enca', Mp4Parser.audioSampleEntry)
  269.         .box('encv', Mp4Parser.visualSampleEntry)
  270.         .box('sinf', Mp4Parser.children)
  271.         .box('frma', (box) => {
  272.           const {codec} = shaka.util.Mp4BoxParsers.parseFRMA(box.reader);
  273.           addCodec(codec);
  274.         })
  276.         .parse(initData || data, /* partialOkay= */ true);
  277.     if (!codecs.length) {
  278.       return null;
  279.     }
  280.     const onlyAudio = hasAudio && !hasVideo;
  281.     const closedCaptions = new Map();
  282.     if (hasVideo) {
  283.       const captionParser = new shaka.media.ClosedCaptionParser('video/mp4');
  284.       if (initData) {
  285.         captionParser.init(initData);
  286.       }
  287.       captionParser.parseFrom(data);
  288.       for (const stream of captionParser.getStreams()) {
  289.         closedCaptions.set(stream, stream);
  290.       }
  291.       captionParser.reset();
  292.     }
  293.     return {
  294.       type: onlyAudio ? 'audio' : 'video',
  295.       mimeType: onlyAudio ? 'audio/mp4' : 'video/mp4',
  296.       codecs: SegmentUtils.filterDuplicateCodecs_(codecs).join(', '),
  297.       language: language,
  298.       height: height,
  299.       width: width,
  300.       channelCount: channelCount,
  301.       sampleRate: sampleRate,
  302.       closedCaptions: closedCaptions,
  303.     };
  304.   }
  306.   /**
  307.    * @param {!Array.<string>} codecs
  308.    * @return {!Array.<string>} codecs
  309.    * @private
  310.    */
  311.   static filterDuplicateCodecs_(codecs) {
  312.     // Filter out duplicate codecs.
  313.     const seen = new Set();
  314.     const ret = [];
  315.     for (const codec of codecs) {
  316.       const shortCodec = shaka.util.MimeUtils.getCodecBase(codec);
  317.       if (!seen.has(shortCodec)) {
  318.         ret.push(codec);
  319.         seen.add(shortCodec);
  320.       } else {
  321.         shaka.log.debug('Ignoring duplicate codec');
  322.       }
  323.     }
  324.     return ret;
  325.   }
  326. };
  329. /**
  330.  * @typedef {{
  331.  *   type: string,
  332.  *   mimeType: string,
  333.  *   codecs: string,
  334.  *   language: ?string,
  335.  *   height: ?string,
  336.  *   width: ?string,
  337.  *   channelCount: ?number,
  338.  *   sampleRate: ?number,
  339.  *   closedCaptions: Map.<string, string>
  340.  * }}
  341.  *
  342.  * @property {string} type
  343.  * @property {string} mimeType
  344.  * @property {string} codecs
  345.  * @property {?string} language
  346.  * @property {?string} height
  347.  * @property {?string} width
  348.  * @property {?number} channelCount
  349.  * @property {?number} sampleRate
  350.  * @property {Map.<string, string>} closedCaptions
  351.  */
  352. shaka.media.SegmentUtils.BasicInfo;