Source: lib/media/closed_caption_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.ClosedCaptionParser');
  8. goog.provide('shaka.media.IClosedCaptionParser');
  10. goog.require('shaka.cea.DummyCaptionDecoder');
  11. goog.require('shaka.cea.DummyCeaParser');
  12. goog.require('shaka.log');
  13. goog.require('shaka.util.BufferUtils');
  16. /**
  17.  * The IClosedCaptionParser defines the interface to provide all operations for
  18.  * parsing the closed captions embedded in Dash videos streams.
  19.  * TODO: Remove this interface and move method definitions
  20.  * directly to ClosedCaptionParser.
  21.  * @interface
  22.  * @export
  23.  */
  24. shaka.media.IClosedCaptionParser = class {
  25.   /**
  26.    * Initialize the caption parser. This should be called whenever new init
  27.    * segment arrives.
  28.    * @param {BufferSource} initSegment
  29.    * @param {boolean=} adaptation True if we just automatically switched active
  30.    *   variant(s).
  31.    */
  32.   init(initSegment, adaptation = false) {}
  34.   /**
  35.    * Parses embedded CEA closed captions and interacts with the underlying
  36.    * CaptionStream, and calls the callback function when there are closed
  37.    * captions.
  38.    *
  39.    * @param {BufferSource} mediaFragment
  40.    * @return {!Array<!shaka.extern.ICaptionDecoder.ClosedCaption>}
  41.    * An array of parsed closed captions.
  42.    */
  43.   parseFrom(mediaFragment) {}
  45.   /**
  46.    * Resets the CaptionStream.
  47.    */
  48.   reset() {}
  50.   /**
  51.    * Returns the streams that the CEA decoder found.
  52.    * @return {!Array<string>}
  53.    */
  54.   getStreams() {}
  55. };
  57. /**
  58.  * Closed Caption Parser provides all operations for parsing the closed captions
  59.  * embedded in Dash videos streams.
  60.  *
  61.  * @implements {shaka.media.IClosedCaptionParser}
  62.  * @final
  63.  * @export
  64.  */
  65. shaka.media.ClosedCaptionParser = class {
  66.   /**
  67.    * @param {string} mimeType
  68.    */
  69.   constructor(mimeType) {
  70.     /** @private {!shaka.extern.ICeaParser} */
  71.     this.ceaParser_ = new shaka.cea.DummyCeaParser();
  73.     const parserFactory =
  74.         shaka.media.ClosedCaptionParser.findParser(mimeType.toLowerCase());
  75.     if (parserFactory) {
  76.       this.ceaParser_ = parserFactory();
  77.     }
  79.     /**
  80.      * Decoder for decoding CEA-X08 data from closed caption packets.
  81.      * @private {!shaka.extern.ICaptionDecoder}
  82.      */
  83.     this.ceaDecoder_ = new shaka.cea.DummyCaptionDecoder();
  85.     const decoderFactory = shaka.media.ClosedCaptionParser.findDecoder();
  86.     if (decoderFactory) {
  87.       this.ceaDecoder_ = decoderFactory();
  88.     }
  89.   }
  91.   /**
  92.    * @override
  93.    */
  94.   init(initSegment, adaptation = false) {
  95.     shaka.log.debug('Passing new init segment to CEA parser');
  96.     if (!adaptation) {
  97.       // Reset underlying decoder when new init segment arrives
  98.       // to clear stored pts values.
  99.       // This is necessary when a new Period comes in DASH or a discontinuity
  100.       // in HLS.
  101.       this.reset();
  102.     }
  103.     this.ceaParser_.init(initSegment);
  104.   }
  106.   /**
  107.    * @override
  108.    */
  109.   parseFrom(mediaFragment) {
  110.     // Parse the fragment.
  111.     const captionPackets = this.ceaParser_.parse(mediaFragment);
  113.     // Extract the caption packets for decoding.
  114.     for (const captionPacket of captionPackets) {
  115.       const uint8ArrayData =
  116.           shaka.util.BufferUtils.toUint8(captionPacket.packet);
  117.       if (uint8ArrayData.length > 0) {
  118.         this.ceaDecoder_.extract(uint8ArrayData, captionPacket.pts);
  119.       }
  120.     }
  122.     // Decode and return the parsed captions.
  123.     return this.ceaDecoder_.decode();
  124.   }
  126.   /**
  127.    * @override
  128.    */
  129.   reset() {
  130.     this.ceaDecoder_.clear();
  131.   }
  133.   /**
  134.    * @override
  135.    */
  136.   getStreams() {
  137.     return this.ceaDecoder_.getStreams();
  138.   }
  140.   /**
  141.    * @param {string} mimeType
  142.    * @param {!shaka.extern.CeaParserPlugin} plugin
  143.    * @export
  144.    */
  145.   static registerParser(mimeType, plugin) {
  146.     shaka.media.ClosedCaptionParser.parserMap_.set(mimeType, plugin);
  147.   }
  149.   /**
  150.    * @param {string} mimeType
  151.    * @export
  152.    */
  153.   static unregisterParser(mimeType) {
  154.     shaka.media.ClosedCaptionParser.parserMap_.delete(mimeType);
  155.   }
  157.   /**
  158.    * @param {string} mimeType
  159.    * @return {?shaka.extern.CeaParserPlugin}
  160.    * @export
  161.    */
  162.   static findParser(mimeType) {
  163.     return shaka.media.ClosedCaptionParser.parserMap_.get(mimeType);
  164.   }
  166.   /**
  167.    * @param {!shaka.extern.CaptionDecoderPlugin} plugin
  168.    * @export
  169.    */
  170.   static registerDecoder(plugin) {
  171.     shaka.media.ClosedCaptionParser.decoderFactory_ = plugin;
  172.   }
  174.   /**
  175.    * @export
  176.    */
  177.   static unregisterDecoder() {
  178.     shaka.media.ClosedCaptionParser.decoderFactory_ = null;
  179.   }
  181.   /**
  182.    * @return {?shaka.extern.CaptionDecoderPlugin}
  183.    * @export
  184.    */
  185.   static findDecoder() {
  186.     return shaka.media.ClosedCaptionParser.decoderFactory_;
  187.   }
  188. };
  190. /** @private {!Map<string, shaka.extern.CeaParserPlugin>} */
  191. shaka.media.ClosedCaptionParser.parserMap_ = new Map();
  193. /** @private {?shaka.extern.CaptionDecoderPlugin} */
  194. shaka.media.ClosedCaptionParser.decoderFactory_ = null;