Source: lib/text/simple_text_displayer.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.text.SimpleTextDisplayer');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.text.Cue');
  25. /**
  26.  * <p>
  27.  * This defines the default text displayer plugin. An instance of this
  28.  * class is used when no custom displayer is given.
  29.  * </p>
  30.  * <p>
  31.  * This class simply converts shaka.text.Cue objects to
  32.  * TextTrackCues and feeds them to the browser.
  33.  * </p>
  34.  *
  35.  * @param {HTMLMediaElement} video
  36.  * @constructor
  37.  * @struct
  38.  * @implements {shakaExtern.TextDisplayer}
  39.  * @export
  40.  */
  41. shaka.text.SimpleTextDisplayer = function(video) {
  42.   /** @private {TextTrack} */
  43.   this.textTrack_ = null;
  45.   // TODO: Test that in all cases, the built-in CC controls in the video element
  46.   // are toggling our TextTrack.
  48.   // If the video element has TextTracks, disable them.  If we see one that
  49.   // was created by a previous instance of Shaka Player, reuse it.
  50.   for (let i = 0; i < video.textTracks.length; ++i) {
  51.     let track = video.textTracks[i];
  52.     track.mode = 'disabled';
  54.     if (track.label == shaka.text.SimpleTextDisplayer.TextTrackLabel_) {
  55.       this.textTrack_ = track;
  56.     }
  57.   }
  59.   if (!this.textTrack_) {
  60.     // As far as I can tell, there is no observable difference between setting
  61.     // kind to 'subtitles' or 'captions' when creating the TextTrack object.
  62.     // The individual text tracks from the manifest will still have their own
  63.     // kinds which can be displayed in the app's UI.
  64.     this.textTrack_ = video.addTextTrack(
  65.         'subtitles', shaka.text.SimpleTextDisplayer.TextTrackLabel_);
  66.   }
  67.   this.textTrack_.mode = 'hidden';
  68. };
  71. /**
  72.  * @override
  73.  * @export
  74.  */
  75. shaka.text.SimpleTextDisplayer.prototype.remove = function(start, end) {
  76.   // Check that the displayer hasn't been destroyed.
  77.   if (!this.textTrack_) return false;
  79.   let removeInRange = (cue) => {
  80.     let outside = cue.startTime >= end || cue.endTime <= start;
  81.     let inside = !outside;
  83.     return inside;
  84.   };
  86.   shaka.text.SimpleTextDisplayer.removeWhere_(this.textTrack_, removeInRange);
  88.   return true;
  89. };
  92. /**
  93.  * @override
  94.  * @export
  95.  */
  96. shaka.text.SimpleTextDisplayer.prototype.append = function(cues) {
  97.   const convertToTextTrackCue =
  98.       shaka.text.SimpleTextDisplayer.convertToTextTrackCue_;
  100.   // Convert cues.
  101.   let textTrackCues = [];
  102.   for (let i = 0; i < cues.length; i++) {
  103.     let cue = convertToTextTrackCue(cues[i]);
  104.     if (cue) {
  105.       textTrackCues.push(cue);
  106.     }
  107.   }
  109.   // Sort the cues based on start/end times.  Make a copy of the array so
  110.   // we can get the index in the original ordering.  Out of order cues are
  111.   // rejected by IE/Edge.  See https://goo.gl/BirBy9
  112.   let sortedCues = textTrackCues.slice().sort(function(a, b) {
  113.     if (a.startTime != b.startTime) {
  114.       return a.startTime - b.startTime;
  115.     } else if (a.endTime != b.endTime) {
  116.       return a.endTime - b.startTime;
  117.     } else {
  118.       // The browser will display cues with identical time ranges from the
  119.       // bottom up.  Reversing the order of equal cues means the first one
  120.       // parsed will be at the top, as you would expect.
  121.       // See https://github.com/google/shaka-player/issues/848 for more info.
  122.       return textTrackCues.indexOf(b) - textTrackCues.indexOf(a);
  123.     }
  124.   });
  126.   sortedCues.forEach(function(cue) {
  127.     this.textTrack_.addCue(cue);
  128.   }.bind(this));
  129. };
  132. /**
  133.  * @override
  134.  * @export
  135.  */
  136. shaka.text.SimpleTextDisplayer.prototype.destroy = function() {
  137.   if (this.textTrack_) {
  138.     let removeIt = (cue) => true;
  139.     shaka.text.SimpleTextDisplayer.removeWhere_(this.textTrack_, removeIt);
  140.   }
  142.   this.textTrack_ = null;
  143.   return Promise.resolve();
  144. };
  147. /**
  148.  * @override
  149.  * @export
  150.  */
  151. shaka.text.SimpleTextDisplayer.prototype.isTextVisible = function() {
  152.   return this.textTrack_.mode == 'showing';
  153. };
  156. /**
  157.  * @override
  158.  * @export
  159.  */
  160. shaka.text.SimpleTextDisplayer.prototype.setTextVisibility = function(on) {
  161.   this.textTrack_.mode = on ? 'showing' : 'hidden';
  162. };
  165. /**
  166.  * @param {!shakaExtern.Cue} shakaCue
  167.  * @return {TextTrackCue}
  168.  * @private
  169.  */
  170. shaka.text.SimpleTextDisplayer.convertToTextTrackCue_ = function(shakaCue) {
  171.   if (shakaCue.startTime >= shakaCue.endTime) {
  172.     // IE/Edge will throw in this case.
  173.     // See issue #501
  174.     shaka.log.warning('Invalid cue times: ' + shakaCue.startTime +
  175.                       ' - ' + shakaCue.endTime);
  176.     return null;
  177.   }
  179.   const Cue = shaka.text.Cue;
  180.   /** @type {VTTCue} */
  181.   let vttCue = new VTTCue(shakaCue.startTime,
  182.                           shakaCue.endTime,
  183.                           shakaCue.payload);
  185.   // NOTE: positionAlign and lineAlign settings are not supported by Chrome
  186.   // at the moment, so setting them will have no effect.
  187.   // The bug on chromium to implement them:
  188.   // https://bugs.chromium.org/p/chromium/issues/detail?id=633690
  190.   vttCue.lineAlign = shakaCue.lineAlign;
  191.   vttCue.positionAlign = shakaCue.positionAlign;
  192.   vttCue.size = shakaCue.size;
  193.   try {
  194.     // Safari 10 seems to throw on align='center'.
  195.     vttCue.align = shakaCue.textAlign;
  196.   } catch (exception) {}
  198.   if (shakaCue.textAlign == 'center' && vttCue.align != 'center') {
  199.     // We want vttCue.position = 'auto'. By default, |position| is set to
  200.     // "auto". If we set it to "auto" safari will throw an exception, so we
  201.     // must rely on the default value.
  202.     vttCue.align = 'middle';
  203.   }
  205.   if (shakaCue.writingDirection ==
  206.           Cue.writingDirection.VERTICAL_LEFT_TO_RIGHT) {
  207.     vttCue.vertical = 'lr';
  208.   } else if (shakaCue.writingDirection ==
  209.            Cue.writingDirection.VERTICAL_RIGHT_TO_LEFT) {
  210.     vttCue.vertical = 'rl';
  211.   }
  213.   // snapToLines flag is true by default
  214.   if (shakaCue.lineInterpretation == Cue.lineInterpretation.PERCENTAGE) {
  215.     vttCue.snapToLines = false;
  216.   }
  218.   if (shakaCue.line != null) {
  219.     vttCue.line = shakaCue.line;
  220.   }
  222.   if (shakaCue.position != null) {
  223.     vttCue.position = shakaCue.position;
  224.   }
  226.   return vttCue;
  227. };
  230. /**
  231.  * Iterate over all the cues in a text track and remove all those for which
  232.  * |predicate(cue)| returns true.
  233.  *
  234.  * @param {!TextTrack} track
  235.  * @param {function(!TextTrackCue):boolean} predicate
  236.  * @private
  237.  */
  238. shaka.text.SimpleTextDisplayer.removeWhere_ = function(track, predicate) {
  239.   // Since |track.cues| can be null if |track.mode| is "disabled", force it to
  240.   // something other than "disabled".
  241.   //
  242.   // If the track is already showing, then we should keep it as showing. But if
  243.   // it something else, we will use hidden so that we don't "flash" cues on the
  244.   // screen.
  245.   let oldState = track.mode;
  246.   let tempState = oldState == 'showing' ? 'showing' : 'hidden';
  248.   track.mode = tempState;
  250.   goog.asserts.assert(
  251.       track.cues,
  252.       'Cues should be accessible when mode is set to "' + tempState + '".');
  254.   // Go backward so that if a removal is done, it should not cause problems
  255.   // with future indexing. In the case that the underlying implementation
  256.   // returns a copy (and not a shared instance) cache a copy of the tracks.
  257.   let cues = track.cues;
  258.   for (let i = cues.length - 1; i >= 0; i--) {
  259.     let cue = cues[i];
  260.     if (cue && predicate(cue)) {
  261.       track.removeCue(cue);
  262.     }
  263.   }
  265.   track.mode = oldState;
  266. };
  269. /**
  270.  * @const {string}
  271.  * @private
  272.  */
  273. shaka.text.SimpleTextDisplayer.TextTrackLabel_ = 'Shaka Player TextTrack';