Source: lib/cea/mp4_cea_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.cea.Mp4CeaParser');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.cea.ICeaParser');
  11. goog.require('shaka.cea.SeiProcessor');
  12. goog.require('shaka.util.DataViewReader');
  13. goog.require('shaka.util.Error');
  14. goog.require('shaka.util.Mp4Parser');
  15. goog.require('shaka.util.Mp4BoxParsers');
  17. /**
  18.  * MPEG4 stream parser used for extracting 708 closed captions data.
  19.  * @implements {shaka.cea.ICeaParser}
  20.  */
  21. shaka.cea.Mp4CeaParser = class {
  22.   /** */
  23.   constructor() {
  24.     /**
  25.      * SEI data processor.
  26.      * @private
  27.      * @const {!shaka.cea.SeiProcessor}
  28.      */
  29.     this.seiProcessor_ = new shaka.cea.SeiProcessor();
  31.     /**
  32.      * Map of track id to corresponding timescale.
  33.      * @private {!Map<number, number>}
  34.      */
  35.     this.trackIdToTimescale_ = new Map();
  37.     /**
  38.      * Default sample duration, as specified by the TREX box.
  39.      * @private {!number}
  40.      */
  41.     this.defaultSampleDuration_ = 0;
  43.     /**
  44.      * Default sample size, as specified by the TREX box.
  45.      * @private {!number}
  46.      */
  47.     this.defaultSampleSize_ = 0;
  48.   }
  50.   /**
  51.    * Parses the init segment. Gets Default Sample Duration and Size from the
  52.    * TREX box, and constructs a map of Track IDs to timescales. Each TRAK box
  53.    * contains a track header (TKHD) containing track ID, and a media header box
  54.    * (MDHD) containing the timescale for the track
  55.    * @override
  56.    */
  57.   init(initSegment) {
  58.     const Mp4Parser = shaka.util.Mp4Parser;
  59.     const trackIds = [];
  60.     const timescales = [];
  62.     new Mp4Parser()
  63.         .box('moov', Mp4Parser.children)
  64.         .box('mvex', Mp4Parser.children)
  65.         .fullBox('trex', (box) => {
  66.           const parsedTREXBox = shaka.util.Mp4BoxParsers.parseTREX(
  67.               box.reader);
  69.           this.defaultSampleDuration_ = parsedTREXBox.defaultSampleDuration;
  70.           this.defaultSampleSize_ = parsedTREXBox.defaultSampleSize;
  71.         })
  72.         .box('trak', Mp4Parser.children)
  73.         .fullBox('tkhd', (box) => {
  74.           goog.asserts.assert(
  75.               box.version != null,
  76.               'TKHD is a full box and should have a valid version.');
  77.           const parsedTKHDBox = shaka.util.Mp4BoxParsers.parseTKHD(
  78.               box.reader, box.version);
  79.           trackIds.push(parsedTKHDBox.trackId);
  80.         })
  81.         .box('mdia', Mp4Parser.children)
  82.         .fullBox('mdhd', (box) => {
  83.           goog.asserts.assert(
  84.               box.version != null,
  85.               'MDHD is a full box and should have a valid version.');
  86.           const parsedMDHDBox = shaka.util.Mp4BoxParsers.parseMDHD(
  87.               box.reader, box.version);
  88.           timescales.push(parsedMDHDBox.timescale);
  89.         })
  90.         .parse(initSegment, /* partialOkay= */ true);
  92.     // At least one track should exist, and each track should have a
  93.     // corresponding Id in TKHD box, and timescale in its MDHD box
  94.     if (!trackIds.length|| !timescales.length ||
  95.       trackIds.length != timescales.length) {
  96.       throw new shaka.util.Error(
  97.           shaka.util.Error.Severity.CRITICAL,
  98.           shaka.util.Error.Category.TEXT,
  99.           shaka.util.Error.Code.INVALID_MP4_CEA);
  100.     }
  102.     // Populate the map from track Id to timescale
  103.     trackIds.forEach((trackId, idx) => {
  104.       this.trackIdToTimescale_.set(trackId, timescales[idx]);
  105.     });
  106.   }
  108.   /**
  109.    * Parses each video segment. In fragmented MP4s, MOOF and MDAT come in
  110.    * pairs. The following logic gets the necessary info from MOOFs to parse
  111.    * MDATs (base media decode time, sample sizes/offsets/durations, etc),
  112.    * and then parses the MDAT boxes for CEA-708 packets using this information.
  113.    * CEA-708 packets are returned in the callback.
  114.    * @override
  115.    */
  116.   parse(mediaSegment) {
  117.     const Mp4Parser = shaka.util.Mp4Parser;
  119.     /** @type {!Array<!shaka.cea.ICeaParser.CaptionPacket>} **/
  120.     const captionPackets = [];
  122.     // Fields that are found in MOOF boxes
  123.     let defaultSampleDuration = this.defaultSampleDuration_;
  124.     let defaultSampleSize = this.defaultSampleSize_;
  125.     let sampleData = [];
  126.     let baseMediaDecodeTime = null;
  127.     let timescale = shaka.cea.ICeaParser.DEFAULT_TIMESCALE_VALUE;
  129.     new Mp4Parser()
  130.         .box('moof', Mp4Parser.children)
  131.         .box('traf', Mp4Parser.children)
  132.         .fullBox('trun', (box) => {
  133.           goog.asserts.assert(
  134.               box.version != null && box.flags!=null,
  135.               'TRUN is a full box and should have a valid version & flags.');
  137.           const parsedTRUN = shaka.util.Mp4BoxParsers.parseTRUN(
  138.               box.reader, box.version, box.flags);
  140.           sampleData = parsedTRUN.sampleData;
  141.         })
  143.         .fullBox('tfhd', (box) => {
  144.           goog.asserts.assert(
  145.               box.flags != null,
  146.               'TFHD is a full box and should have valid flags.');
  148.           const parsedTFHD = shaka.util.Mp4BoxParsers.parseTFHD(
  149.               box.reader, box.flags);
  151.           // If specified, defaultSampleDuration and defaultSampleSize
  152.           // override the ones specified in the TREX box
  153.           defaultSampleDuration = parsedTFHD.defaultSampleDuration ||
  154.               this.defaultSampleDuration_;
  156.           defaultSampleSize = parsedTFHD.defaultSampleSize ||
  157.               this.defaultSampleSize_;
  159.           const trackId = parsedTFHD.trackId;
  161.           // Get the timescale from the track Id
  162.           if (this.trackIdToTimescale_.has(trackId)) {
  163.             timescale = this.trackIdToTimescale_.get(trackId);
  164.           }
  165.         })
  167.         .fullBox('tfdt', (box) => {
  168.           goog.asserts.assert(
  169.               box.version != null,
  170.               'TFDT is a full box and should have a valid version.');
  172.           const parsedTFDT = shaka.util.Mp4BoxParsers.parseTFDT(
  173.               box.reader, box.version);
  175.           baseMediaDecodeTime = parsedTFDT.baseMediaDecodeTime;
  176.         })
  177.         .box('mdat', (box) => {
  178.           if (baseMediaDecodeTime === null) {
  179.             // This field should have been populated by
  180.             // the Base Media Decode time in the TFDT box
  181.             throw new shaka.util.Error(
  182.                 shaka.util.Error.Severity.CRITICAL,
  183.                 shaka.util.Error.Category.TEXT,
  184.                 shaka.util.Error.Code.INVALID_MP4_CEA);
  185.           }
  186.           this.parseMdat_(box.reader, baseMediaDecodeTime, timescale,
  187.               defaultSampleDuration, defaultSampleSize, sampleData,
  188.               captionPackets);
  189.         })
  190.         .parse(mediaSegment, /* partialOkay= */ false);
  192.     return captionPackets;
  193.   }
  195.   /**
  196.    * Parse MDAT box.
  197.    * @param {!shaka.util.DataViewReader} reader
  198.    * @param {!number} time
  199.    * @param {!number} timescale
  200.    * @param {!number} defaultSampleDuration
  201.    * @param {!number} defaultSampleSize
  202.    * @param {!Array<shaka.util.ParsedTRUNSample>} sampleData
  203.    * @param {!Array<!shaka.cea.ICeaParser.CaptionPacket>} captionPackets
  204.    * @private
  205.    */
  206.   parseMdat_(reader, time, timescale, defaultSampleDuration,
  207.       defaultSampleSize, sampleData, captionPackets) {
  208.     let sampleIndex = 0;
  210.     // The fields in each ParsedTRUNSample contained in the sampleData
  211.     // array are nullable. In the case of sample data and sample duration,
  212.     // we use the defaults provided by the TREX/TFHD boxes. For sample
  213.     // composition time offset, we default to 0.
  214.     let sampleSize = defaultSampleSize;
  216.     if (sampleData.length) {
  217.       sampleSize = sampleData[0].sampleSize || defaultSampleSize;
  218.     }
  220.     while (reader.hasMoreData()) {
  221.       const naluSize = reader.readUint32();
  222.       const naluType = reader.readUint8() & 0x1F;
  223.       if (naluType == shaka.cea.ICeaParser.NALU_TYPE_SEI) {
  224.         let timeOffset = 0;
  226.         if (sampleData.length > sampleIndex) {
  227.           timeOffset = sampleData[sampleIndex].sampleCompositionTimeOffset || 0;
  228.         }
  230.         const pts = (time + timeOffset)/timescale;
  231.         for (const packet of this.seiProcessor_
  232.             .process(reader.readBytes(naluSize - 1))) {
  233.           captionPackets.push({
  234.             packet,
  235.             pts,
  236.           });
  237.         }
  238.       } else {
  239.         try {
  240.           reader.skip(naluSize - 1);
  241.         } catch (e) {
  242.           // It is necessary to ignore this error because it can break the start
  243.           // of playback even if the user does not want to see the subtitles.
  244.           break;
  245.         }
  246.       }
  247.       sampleSize -= (naluSize + 4);
  248.       if (sampleSize == 0) {
  249.         if (sampleData.length > sampleIndex) {
  250.           time += sampleData[sampleIndex].sampleDuration ||
  251.               defaultSampleDuration;
  252.         } else {
  253.           time += defaultSampleDuration;
  254.         }
  256.         sampleIndex++;
  258.         if (sampleData.length > sampleIndex) {
  259.           sampleSize = sampleData[sampleIndex].sampleSize || defaultSampleSize;
  260.         } else {
  261.           sampleSize = defaultSampleSize;
  262.         }
  263.       }
  264.     }
  265.   }
  266. };