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.util.BufferUtils');
  15. /**
  16.  * The IClosedCaptionParser defines the interface to provide all operations for
  17.  * parsing the closed captions embedded in Dash videos streams.
  18.  * TODO: Remove this interface and move method definitions
  19.  * directly to ClosedCaptonParser.
  20.  * @interface
  21.  * @export
  22.  */
  23. shaka.media.IClosedCaptionParser = class {
  24.   /**
  25.    * Initialize the caption parser. This should be called only once.
  26.    * @param {BufferSource} initSegment
  27.    */
  28.   init(initSegment) {}
  30.   /**
  31.    * Parses embedded CEA closed captions and interacts with the underlying
  32.    * CaptionStream, and calls the callback function when there are closed
  33.    * captions.
  34.    *
  35.    * @param {BufferSource} mediaFragment
  36.    * @return {!Array<!shaka.extern.ICaptionDecoder.ClosedCaption>}
  37.    * An array of parsed closed captions.
  38.    */
  39.   parseFrom(mediaFragment) {}
  41.   /**
  42.    * Resets the CaptionStream.
  43.    */
  44.   reset() {}
  45. };
  47. /**
  48.  * Closed Caption Parser provides all operations for parsing the closed captions
  49.  * embedded in Dash videos streams.
  50.  *
  51.  * @implements {shaka.media.IClosedCaptionParser}
  52.  * @final
  53.  * @export
  54.  */
  55. shaka.media.ClosedCaptionParser = class {
  56.   /**
  57.    * @param {string} mimeType
  58.    */
  59.   constructor(mimeType) {
  60.     /** @private {!shaka.extern.ICeaParser} */
  61.     this.ceaParser_ = new shaka.cea.DummyCeaParser();
  63.     const parserFactory =
  64.         shaka.media.ClosedCaptionParser.findParser(mimeType.toLowerCase());
  65.     if (parserFactory) {
  66.       this.ceaParser_ = parserFactory();
  67.     }
  69.     /**
  70.      * Decoder for decoding CEA-X08 data from closed caption packets.
  71.      * @private {!shaka.extern.ICaptionDecoder}
  72.      */
  73.     this.ceaDecoder_ = new shaka.cea.DummyCaptionDecoder();
  75.     const decoderFactory = shaka.media.ClosedCaptionParser.findDecoder();
  76.     if (decoderFactory) {
  77.       this.ceaDecoder_ = decoderFactory();
  78.     }
  79.   }
  81.   /**
  82.    * @override
  83.    */
  84.   init(initSegment) {
  85.     this.ceaParser_.init(initSegment);
  86.   }
  88.   /**
  89.    * @override
  90.    */
  91.   parseFrom(mediaFragment) {
  92.     // Parse the fragment.
  93.     const captionPackets = this.ceaParser_.parse(mediaFragment);
  95.     // Extract the caption packets for decoding.
  96.     for (const captionPacket of captionPackets) {
  97.       const uint8ArrayData =
  98.           shaka.util.BufferUtils.toUint8(captionPacket.packet);
  99.       if (uint8ArrayData.length > 0) {
  100.         this.ceaDecoder_.extract(uint8ArrayData, captionPacket.pts);
  101.       }
  102.     }
  104.     // Decode and return the parsed captions.
  105.     return this.ceaDecoder_.decode();
  106.   }
  108.   /**
  109.    * @override
  110.    */
  111.   reset() {
  112.     this.ceaDecoder_.clear();
  113.   }
  115.   /**
  116.    * @param {string} mimeType
  117.    * @param {!shaka.extern.CeaParserPlugin} plugin
  118.    * @export
  119.    */
  120.   static registerParser(mimeType, plugin) {
  121.     shaka.media.ClosedCaptionParser.parserMap_[mimeType] = plugin;
  122.   }
  124.   /**
  125.    * @param {string} mimeType
  126.    * @export
  127.    */
  128.   static unregisterParser(mimeType) {
  129.     delete shaka.media.ClosedCaptionParser.parserMap_[mimeType];
  130.   }
  132.   /**
  133.    * @param {string} mimeType
  134.    * @return {?shaka.extern.CeaParserPlugin}
  135.    * @export
  136.    */
  137.   static findParser(mimeType) {
  138.     return shaka.media.ClosedCaptionParser.parserMap_[mimeType];
  139.   }
  141.   /**
  142.    * @param {!shaka.extern.CaptionDecoderPlugin} plugin
  143.    * @export
  144.    */
  145.   static registerDecoder(plugin) {
  146.     shaka.media.ClosedCaptionParser.decoderFactory_ = plugin;
  147.   }
  149.   /**
  150.    * @export
  151.    */
  152.   static unregisterDecoder() {
  153.     shaka.media.ClosedCaptionParser.decoderFactory_ = null;
  154.   }
  156.   /**
  157.    * @return {?shaka.extern.CaptionDecoderPlugin}
  158.    * @export
  159.    */
  160.   static findDecoder() {
  161.     return shaka.media.ClosedCaptionParser.decoderFactory_;
  162.   }
  163. };
  165. /** @private {!Object<string, shaka.extern.CeaParserPlugin>} */
  166. shaka.media.ClosedCaptionParser.parserMap_ = {};
  168. /** @private {?shaka.extern.CaptionDecoderPlugin} */
  169. shaka.media.ClosedCaptionParser.decoderFactory_ = null;