Source: lib/media/media_source_engine.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.MediaSourceEngine');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.config.CodecSwitchingStrategy');
  12. goog.require('shaka.media.Capabilities');
  13. goog.require('shaka.media.ContentWorkarounds');
  14. goog.require('shaka.media.ClosedCaptionParser');
  15. goog.require('shaka.media.IClosedCaptionParser');
  16. goog.require('shaka.media.ManifestParser');
  17. goog.require('shaka.media.SegmentReference');
  18. goog.require('shaka.media.TimeRangesUtils');
  19. goog.require('shaka.text.TextEngine');
  20. goog.require('shaka.transmuxer.TransmuxerEngine');
  21. goog.require('shaka.util.BufferUtils');
  22. goog.require('shaka.util.Destroyer');
  23. goog.require('shaka.util.Dom');
  24. goog.require('shaka.util.Error');
  25. goog.require('shaka.util.EventManager');
  26. goog.require('shaka.util.FakeEvent');
  27. goog.require('shaka.util.Functional');
  28. goog.require('shaka.util.IDestroyable');
  29. goog.require('shaka.util.Id3Utils');
  30. goog.require('shaka.util.ManifestParserUtils');
  31. goog.require('shaka.util.MimeUtils');
  32. goog.require('shaka.util.Mp4BoxParsers');
  33. goog.require('shaka.util.Mp4Parser');
  34. goog.require('shaka.util.Platform');
  35. goog.require('shaka.util.PublicPromise');
  36. goog.require('shaka.util.StreamUtils');
  37. goog.require('shaka.util.TsParser');
  38. goog.require('shaka.lcevc.Dec');
  41. /**
  42.  * @summary
  43.  * MediaSourceEngine wraps all operations on MediaSource and SourceBuffers.
  44.  * All asynchronous operations return a Promise, and all operations are
  45.  * internally synchronized and serialized as needed.  Operations that can
  46.  * be done in parallel will be done in parallel.
  47.  *
  48.  * @implements {shaka.util.IDestroyable}
  49.  */
  50. shaka.media.MediaSourceEngine = class {
  51.   /**
  52.    * @param {HTMLMediaElement} video The video element, whose source is tied to
  53.    *   MediaSource during the lifetime of the MediaSourceEngine.
  54.    * @param {!shaka.extern.TextDisplayer} textDisplayer
  55.    *    The text displayer that will be used with the text engine.
  56.    *    MediaSourceEngine takes ownership of the displayer. When
  57.    *    MediaSourceEngine is destroyed, it will destroy the displayer.
  58.    * @param {!shaka.media.MediaSourceEngine.PlayerInterface} playerInterface
  59.    *   Interface for common player methods.
  60.    * @param {?shaka.lcevc.Dec} [lcevcDec] Optional -  LCEVC Decoder Object
  61.    */
  62.   constructor(video, textDisplayer, playerInterface, lcevcDec) {
  63.     /** @private {HTMLMediaElement} */
  64.     this.video_ = video;
  66.     /** @private {?shaka.media.MediaSourceEngine.PlayerInterface} */
  67.     this.playerInterface_ = playerInterface;
  69.     /** @private {?shaka.extern.MediaSourceConfiguration} */
  70.     this.config_ = null;
  72.     /** @private {shaka.extern.TextDisplayer} */
  73.     this.textDisplayer_ = textDisplayer;
  75.     /**
  76.      * @private {!Map<shaka.util.ManifestParserUtils.ContentType, SourceBuffer>}
  77.      */
  78.     this.sourceBuffers_ = new Map();
  80.     /**
  81.      * @private {!Map<shaka.util.ManifestParserUtils.ContentType, string>}
  82.      */
  83.     this.sourceBufferTypes_ = new Map();
  86.     /**
  87.      * @private {!Map<shaka.util.ManifestParserUtils.ContentType,
  88.      *                    boolean>}
  89.      */
  90.     this.expectedEncryption_ = new Map();
  92.     /** @private {shaka.text.TextEngine} */
  93.     this.textEngine_ = null;
  95.     /** @private {boolean} */
  96.     this.segmentRelativeVttTiming_ = false;
  98.     /** @private {?shaka.lcevc.Dec} */
  99.     this.lcevcDec_ = lcevcDec || null;
  101.     /**
  102.      * @private {!Map<string, !Array<shaka.media.MediaSourceEngine.Operation>>}
  103.      */
  104.     this.queues_ = new Map();
  106.     /** @private {shaka.util.EventManager} */
  107.     this.eventManager_ = new shaka.util.EventManager();
  109.     /**
  110.      * @private {!Map<shaka.util.ManifestParserUtils.ContentType,
  111.                          !shaka.extern.Transmuxer>} */
  112.     this.transmuxers_ = new Map();
  114.     /** @private {?shaka.media.IClosedCaptionParser} */
  115.     this.captionParser_ = null;
  117.     /** @private {!shaka.util.PublicPromise} */
  118.     this.mediaSourceOpen_ = new shaka.util.PublicPromise();
  120.     /** @private {string} */
  121.     this.url_ = '';
  123.     /** @private {boolean} */
  124.     this.playbackHasBegun_ = false;
  126.     /** @private {boolean} */
  127.     this.streamingAllowed_ = true;
  129.     /** @private {boolean} */
  130.     this.usingRemotePlayback_ = false;
  132.     /** @private {HTMLSourceElement} */
  133.     this.source_ = null;
  135.     /**
  136.      * Fallback source element with direct media URI, used for casting
  137.      * purposes.
  138.      * @private {HTMLSourceElement}
  139.      */
  140.     this.secondarySource_ = null;
  142.     /** @private {MediaSource} */
  143.     this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
  145.     /** @private {boolean} */
  146.     this.reloadingMediaSource_ = false;
  148.     /** @private {boolean} */
  149.     this.playAfterReset_ = false;
  151.     /** @type {!shaka.util.Destroyer} */
  152.     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
  154.     /** @private {boolean} */
  155.     this.sequenceMode_ = false;
  157.     /** @private {string} */
  158.     this.manifestType_ = shaka.media.ManifestParser.UNKNOWN;
  160.     /** @private {boolean} */
  161.     this.ignoreManifestTimestampsInSegmentsMode_ = false;
  163.     /** @private {boolean} */
  164.     this.attemptTimestampOffsetCalculation_ = false;
  166.     /** @private {!shaka.util.PublicPromise<number>} */
  167.     this.textSequenceModeOffset_ = new shaka.util.PublicPromise();
  169.     /** @private {boolean} */
  170.     this.needSplitMuxedContent_ = false;
  172.     /** @private {?number} */
  173.     this.lastDuration_ = null;
  175.     /**
  176.      * @private {!Map<shaka.util.ManifestParserUtils.ContentType,
  177.      *                    !shaka.util.TsParser>}
  178.      */
  179.     this.tsParsers_ = new Map();
  181.     /** @private {?number} */
  182.     this.firstVideoTimestamp_ = null;
  184.     /** @private {?number} */
  185.     this.firstVideoReferenceStartTime_ = null;
  187.     /** @private {?number} */
  188.     this.firstAudioTimestamp_ = null;
  190.     /** @private {?number} */
  191.     this.firstAudioReferenceStartTime_ = null;
  193.     /** @private {!shaka.util.PublicPromise<number>} */
  194.     this.audioCompensation_ = new shaka.util.PublicPromise();
  196.     if (this.video_.remote) {
  197.       this.usingRemotePlayback_ = this.video_.remote.state != 'disconnected';
  199.       this.eventManager_.listen(this.video_.remote, 'connect', () => {
  200.         this.usingRemotePlayback_ = this.video_.remote.state != 'disconnected';
  201.       });
  203.       this.eventManager_.listen(this.video_.remote, 'connecting', () => {
  204.         this.usingRemotePlayback_ = this.video_.remote.state != 'disconnected';
  205.       });
  207.       this.eventManager_.listen(this.video_.remote, 'disconnect', () => {
  208.         this.usingRemotePlayback_ = this.video_.remote.state != 'disconnected';
  209.       });
  210.     }
  211.   }
  213.   /**
  214.    * Create a MediaSource object, attach it to the video element, and return it.
  215.    * Resolves the given promise when the MediaSource is ready.
  216.    *
  217.    * Replaced by unit tests.
  218.    *
  219.    * @param {!shaka.util.PublicPromise} p
  220.    * @return {!MediaSource}
  221.    */
  222.   createMediaSource(p) {
  223.     this.streamingAllowed_ = true;
  225.     /** @type {!MediaSource} */
  226.     let mediaSource;
  228.     if (window.ManagedMediaSource) {
  229.       if (!this.secondarySource_) {
  230.         this.video_.disableRemotePlayback = true;
  231.       }
  233.       mediaSource = new ManagedMediaSource();
  235.       this.eventManager_.listen(
  236.           mediaSource, 'startstreaming', () => {
  237.             shaka.log.info('MMS startstreaming');
  238.             this.streamingAllowed_ = true;
  239.           });
  241.       this.eventManager_.listen(
  242.           mediaSource, 'endstreaming', () => {
  243.             shaka.log.info('MMS endstreaming');
  244.             this.streamingAllowed_ = false;
  245.           });
  246.     } else {
  247.       mediaSource = new MediaSource();
  248.     }
  250.     // Set up MediaSource on the video element.
  251.     this.eventManager_.listenOnce(
  252.         mediaSource, 'sourceopen', () => this.onSourceOpen_(p));
  254.     // Correctly set when playback has begun.
  255.     this.eventManager_.listenOnce(this.video_, 'playing', () => {
  256.       this.playbackHasBegun_ = true;
  257.     });
  259.     // Store the object URL for releasing it later.
  260.     this.url_ = shaka.media.MediaSourceEngine.createObjectURL(mediaSource);
  262.     this.video_.removeAttribute('src');
  263.     if (this.source_) {
  264.       this.video_.removeChild(this.source_);
  265.     }
  266.     if (this.secondarySource_) {
  267.       this.video_.removeChild(this.secondarySource_);
  268.     }
  269.     this.source_ = shaka.util.Dom.createSourceElement(this.url_);
  270.     this.video_.appendChild(this.source_);
  271.     if (this.secondarySource_) {
  272.       this.video_.appendChild(this.secondarySource_);
  273.     }
  274.     this.video_.load();
  276.     return mediaSource;
  277.   }
  279.   /**
  280.    * @param {string} uri
  281.    * @param {string} mimeType
  282.    */
  283.   addSecondarySource(uri, mimeType) {
  284.     if (!this.video_ || !window.ManagedMediaSource || !this.mediaSource_) {
  285.       shaka.log.warning(
  286.           'Secondary source is used only with ManagedMediaSource');
  287.       return;
  288.     }
  289.     if (this.secondarySource_) {
  290.       this.video_.removeChild(this.secondarySource_);
  291.     }
  292.     this.secondarySource_ = shaka.util.Dom.createSourceElement(uri, mimeType);
  293.     this.video_.appendChild(this.secondarySource_);
  294.     this.video_.disableRemotePlayback = false;
  295.   }
  297.   /**
  298.    * @param {shaka.util.PublicPromise} p
  299.    * @private
  300.    */
  301.   onSourceOpen_(p) {
  302.     goog.asserts.assert(this.url_, 'Must have object URL');
  304.     // Release the object URL that was previously created, to prevent memory
  305.     // leak.
  306.     // createObjectURL creates a strong reference to the MediaSource object
  307.     // inside the browser.  Setting the src of the video then creates another
  308.     // reference within the video element.  revokeObjectURL will remove the
  309.     // strong reference to the MediaSource object, and allow it to be
  310.     // garbage-collected later.
  311.     URL.revokeObjectURL(this.url_);
  312.     p.resolve();
  313.   }
  315.   /**
  316.    * Checks if a certain type is supported.
  317.    *
  318.    * @param {shaka.extern.Stream} stream
  319.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  320.    * @return {!Promise<boolean>}
  321.    */
  322.   static async isStreamSupported(stream, contentType) {
  323.     if (stream.createSegmentIndex) {
  324.       await stream.createSegmentIndex();
  325.     }
  326.     if (!stream.segmentIndex) {
  327.       return false;
  328.     }
  329.     if (stream.segmentIndex.isEmpty()) {
  330.       return true;
  331.     }
  332.     const MimeUtils = shaka.util.MimeUtils;
  333.     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
  334.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  335.     const StreamUtils = shaka.util.StreamUtils;
  336.     const seenCombos = new Set();
  337.     // Check each combination of mimeType and codecs within the segment index.
  338.     // Unfortunately we cannot use fullMimeTypes, as we ALSO need to check the
  339.     // getFullTypeWithAllCodecs (for the sake of the transmuxer) and we have no
  340.     // way of going from a full mimeType to a full mimeType with all codecs.
  341.     // As this function is only called in debug mode, a little inefficiency is
  342.     // acceptable.
  343.     for (const ref of stream.segmentIndex) {
  344.       const mimeType = ref.mimeType || stream.mimeType || '';
  345.       let codecs = ref.codecs || stream.codecs || '';
  346.       // Optimization for the case where the codecs and mimetype of the stream
  347.       // match the reference.
  348.       if (mimeType == stream.mimeType && codecs == stream.codecs) {
  349.         continue;
  350.       }
  351.       // Don't check the same combination of mimetype + codecs twice.
  352.       const combo = mimeType + ':' + codecs;
  353.       if (seenCombos.has(combo)) {
  354.         continue;
  355.       }
  356.       seenCombos.add(combo);
  357.       if (contentType == ContentType.TEXT) {
  358.         const fullMimeType = MimeUtils.getFullType(mimeType, codecs);
  359.         if (!shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
  360.           return false;
  361.         }
  362.       } else {
  363.         if (contentType == ContentType.VIDEO) {
  364.           codecs = StreamUtils.getCorrectVideoCodecs(codecs);
  365.         } else if (contentType == ContentType.AUDIO) {
  366.           codecs = StreamUtils.getCorrectAudioCodecs(codecs, mimeType);
  367.         }
  368.         const extendedMimeType = MimeUtils.getExtendedType(
  369.             stream, mimeType, codecs);
  370.         const fullMimeType = MimeUtils.getFullTypeWithAllCodecs(
  371.             mimeType, codecs);
  372.         if (!shaka.media.Capabilities.isTypeSupported(extendedMimeType) &&
  373.             !TransmuxerEngine.isSupported(fullMimeType, stream.type)) {
  374.           return false;
  375.         }
  376.       }
  377.     }
  378.     return true;
  379.   }
  381.   /**
  382.    * Returns a map of MediaSource support for well-known types.
  383.    *
  384.    * @return {!Object<string, boolean>}
  385.    */
  386.   static probeSupport() {
  387.     const testMimeTypes = [
  388.       // MP4 types
  389.       'video/mp4; codecs="avc1.42E01E"',
  390.       'video/mp4; codecs="avc3.42E01E"',
  391.       'video/mp4; codecs="hev1.1.6.L93.90"',
  392.       'video/mp4; codecs="hvc1.1.6.L93.90"',
  393.       'video/mp4; codecs="hev1.2.4.L153.B0"; eotf="smpte2084"',  // HDR HEVC
  394.       'video/mp4; codecs="hvc1.2.4.L153.B0"; eotf="smpte2084"',  // HDR HEVC
  395.       'video/mp4; codecs="vp9"',
  396.       'video/mp4; codecs="vp09.00.10.08"',
  397.       'video/mp4; codecs="av01.0.01M.08"',
  398.       'video/mp4; codecs="dvh1.05.01"',
  399.       'video/mp4; codecs="dvh1.20.01"',
  400.       'audio/mp4; codecs="mp4a.40.2"',
  401.       'audio/mp4; codecs="ac-3"',
  402.       'audio/mp4; codecs="ec-3"',
  403.       'audio/mp4; codecs="ac-4.02.01.01"',
  404.       'audio/mp4; codecs="opus"',
  405.       'audio/mp4; codecs="flac"',
  406.       'audio/mp4; codecs="dtsc"', // DTS Digital Surround
  407.       'audio/mp4; codecs="dtse"', // DTS Express
  408.       'audio/mp4; codecs="dtsx"', // DTS:X
  409.       // WebM types
  410.       'video/webm; codecs="vp8"',
  411.       'video/webm; codecs="vp9"',
  412.       'video/webm; codecs="vp09.00.10.08"',
  413.       'audio/webm; codecs="vorbis"',
  414.       'audio/webm; codecs="opus"',
  415.       // MPEG2 TS types (video/ is also used for audio: https://bit.ly/TsMse)
  416.       'video/mp2t; codecs="avc1.42E01E"',
  417.       'video/mp2t; codecs="avc3.42E01E"',
  418.       'video/mp2t; codecs="hvc1.1.6.L93.90"',
  419.       'video/mp2t; codecs="mp4a.40.2"',
  420.       'video/mp2t; codecs="ac-3"',
  421.       'video/mp2t; codecs="ec-3"',
  422.       // WebVTT types
  423.       'text/vtt',
  424.       'application/mp4; codecs="wvtt"',
  425.       // TTML types
  426.       'application/ttml+xml',
  427.       'application/mp4; codecs="stpp"',
  428.       // Containerless types
  429.       ...shaka.util.MimeUtils.RAW_FORMATS,
  430.     ];
  432.     const support = {};
  433.     for (const type of testMimeTypes) {
  434.       if (shaka.text.TextEngine.isTypeSupported(type)) {
  435.         support[type] = true;
  436.       } else if (shaka.util.Platform.supportsMediaSource()) {
  437.         support[type] = shaka.media.Capabilities.isTypeSupported(type) ||
  438.                         shaka.transmuxer.TransmuxerEngine.isSupported(type);
  439.       } else {
  440.         support[type] = shaka.util.Platform.supportsMediaType(type);
  441.       }
  443.       const basicType = type.split(';')[0];
  444.       support[basicType] = support[basicType] || support[type];
  445.     }
  447.     return support;
  448.   }
  450.   /** @override */
  451.   destroy() {
  452.     return this.destroyer_.destroy();
  453.   }
  455.   /** @private */
  456.   async doDestroy_() {
  457.     const Functional = shaka.util.Functional;
  459.     const cleanup = [];
  461.     for (const [key, q] of this.queues_) {
  462.       // Make a local copy of the queue and the first item.
  463.       const inProgress = q[0];
  465.       const contentType = /** @type {string} */(key);
  467.       // Drop everything else out of the original queue.
  468.       this.queues_.set(contentType, q.slice(0, 1));
  470.       // We will wait for this item to complete/fail.
  471.       if (inProgress) {
  472.         cleanup.push(inProgress.p.catch(Functional.noop));
  473.       }
  475.       // The rest will be rejected silently if possible.
  476.       for (const item of q.slice(1)) {
  477.         item.p.reject(shaka.util.Destroyer.destroyedError());
  478.       }
  479.     }
  481.     if (this.textEngine_) {
  482.       cleanup.push(this.textEngine_.destroy());
  483.     }
  485.     await Promise.all(cleanup);
  487.     for (const transmuxer of this.transmuxers_.values()) {
  488.       transmuxer.destroy();
  489.     }
  491.     if (this.eventManager_) {
  492.       this.eventManager_.release();
  493.       this.eventManager_ = null;
  494.     }
  496.     if (this.video_ && this.secondarySource_) {
  497.       this.video_.removeChild(this.secondarySource_);
  498.     }
  499.     if (this.video_ && this.source_) {
  500.       // "unload" the video element.
  501.       this.video_.removeChild(this.source_);
  502.       this.video_.load();
  503.       this.video_.disableRemotePlayback = false;
  504.     }
  506.     this.video_ = null;
  507.     this.source_ = null;
  508.     this.secondarySource_ = null;
  509.     this.config_ = null;
  510.     this.mediaSource_ = null;
  511.     this.textEngine_ = null;
  512.     this.textDisplayer_ = null;
  513.     this.sourceBuffers_.clear();
  514.     this.expectedEncryption_.clear();
  515.     this.transmuxers_.clear();
  516.     this.captionParser_ = null;
  517.     if (goog.DEBUG) {
  518.       for (const [contentType, q] of this.queues_) {
  519.         goog.asserts.assert(
  520.             q.length == 0,
  521.             contentType + ' queue should be empty after destroy!');
  522.       }
  523.     }
  524.     this.queues_.clear();
  526.     // This object is owned by Player
  527.     this.lcevcDec_ = null;
  529.     this.tsParsers_.clear();
  530.     this.playerInterface_ = null;
  531.   }
  533.   /**
  534.    * @return {!Promise} Resolved when MediaSource is open and attached to the
  535.    *   media element.  This process is actually initiated by the constructor.
  536.    */
  537.   open() {
  538.     return this.mediaSourceOpen_;
  539.   }
  541.   /**
  542.    * Initialize MediaSourceEngine.
  543.    *
  544.    * Note that it is not valid to call this multiple times, except to add or
  545.    * reinitialize text streams.
  546.    *
  547.    * @param {!Map<shaka.util.ManifestParserUtils.ContentType,
  548.    *               shaka.extern.Stream>} streamsByType
  549.    *   A map of content types to streams.  All streams must be supported
  550.    *   according to MediaSourceEngine.isStreamSupported.
  551.    * @param {boolean=} sequenceMode
  552.    *   If true, the media segments are appended to the SourceBuffer in strict
  553.    *   sequence.
  554.    * @param {string=} manifestType
  555.    *   Indicates the type of the manifest.
  556.    * @param {boolean=} ignoreManifestTimestampsInSegmentsMode
  557.    *   If true, don't adjust the timestamp offset to account for manifest
  558.    *   segment durations being out of sync with segment durations. In other
  559.    *   words, assume that there are no gaps in the segments when appending
  560.    *   to the SourceBuffer, even if the manifest and segment times disagree.
  561.    *   Indicates if the manifest has text streams.
  562.    *
  563.    * @return {!Promise}
  564.    */
  565.   async init(streamsByType, sequenceMode=false,
  566.       manifestType=shaka.media.ManifestParser.UNKNOWN,
  567.       ignoreManifestTimestampsInSegmentsMode=false) {
  568.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  570.     await this.mediaSourceOpen_;
  571.     if (this.ended() || this.closed()) {
  572.       shaka.log.alwaysError('Expected MediaSource to be open during init(); ' +
  573.           'reopening the media source.');
  574.       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
  575.       this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
  576.       await this.mediaSourceOpen_;
  577.     }
  579.     this.sequenceMode_ = sequenceMode;
  580.     this.manifestType_ = manifestType;
  581.     this.ignoreManifestTimestampsInSegmentsMode_ =
  582.       ignoreManifestTimestampsInSegmentsMode;
  584.     this.attemptTimestampOffsetCalculation_ = !this.sequenceMode_ &&
  585.         this.manifestType_ == shaka.media.ManifestParser.HLS &&
  586.         !this.ignoreManifestTimestampsInSegmentsMode_;
  588.     this.tsParsers_.clear();
  589.     this.firstVideoTimestamp_ = null;
  590.     this.firstVideoReferenceStartTime_ = null;
  591.     this.firstAudioTimestamp_ = null;
  592.     this.firstAudioReferenceStartTime_ = null;
  593.     this.audioCompensation_ = new shaka.util.PublicPromise();
  595.     for (const contentType of streamsByType.keys()) {
  596.       const stream = streamsByType.get(contentType);
  597.       // eslint-disable-next-line no-await-in-loop
  598.       await this.initSourceBuffer_(contentType, stream, stream.codecs);
  599.       if (this.needSplitMuxedContent_) {
  600.         this.queues_.set(ContentType.AUDIO, []);
  601.         this.queues_.set(ContentType.VIDEO, []);
  602.       } else {
  603.         this.queues_.set(contentType, []);
  604.       }
  605.     }
  606.     const audio = streamsByType.get(ContentType.AUDIO);
  607.     if (audio && audio.isAudioMuxedInVideo) {
  608.       this.needSplitMuxedContent_ = true;
  609.     }
  610.   }
  612.   /**
  613.    * Initialize a specific SourceBuffer.
  614.    *
  615.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  616.    * @param {shaka.extern.Stream} stream
  617.    * @param {string} codecs
  618.    * @return {!Promise}
  619.    * @private
  620.    */
  621.   async initSourceBuffer_(contentType, stream, codecs) {
  622.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  624.     goog.asserts.assert(
  625.         await shaka.media.MediaSourceEngine.isStreamSupported(
  626.             stream, contentType),
  627.         'Type negotiation should happen before MediaSourceEngine.init!');
  629.     if (contentType == ContentType.AUDIO && codecs) {
  630.       codecs = shaka.util.StreamUtils.getCorrectAudioCodecs(
  631.           codecs, stream.mimeType);
  632.     }
  634.     let mimeType = shaka.util.MimeUtils.getFullType(
  635.         stream.mimeType, codecs);
  636.     if (contentType == ContentType.TEXT) {
  637.       this.reinitText(mimeType, this.sequenceMode_, stream.external);
  638.     } else {
  639.       let needTransmux = this.config_.forceTransmux;
  640.       if (!shaka.media.Capabilities.isTypeSupported(mimeType) ||
  641.           (!this.sequenceMode_ &&
  642.           shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType))) {
  643.         needTransmux = true;
  644.       }
  645.       const mimeTypeWithAllCodecs =
  646.           shaka.util.MimeUtils.getFullTypeWithAllCodecs(
  647.               stream.mimeType, codecs);
  648.       if (needTransmux) {
  649.         const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  650.             ContentType.AUDIO, (codecs || '').split(','));
  651.         const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  652.             ContentType.VIDEO, (codecs || '').split(','));
  653.         if (audioCodec && videoCodec) {
  654.           this.needSplitMuxedContent_ = true;
  655.           await this.initSourceBuffer_(ContentType.AUDIO, stream, audioCodec);
  656.           await this.initSourceBuffer_(ContentType.VIDEO, stream, videoCodec);
  657.           return;
  658.         }
  659.         const transmuxerPlugin = shaka.transmuxer.TransmuxerEngine
  660.             .findTransmuxer(mimeTypeWithAllCodecs);
  661.         if (transmuxerPlugin) {
  662.           const transmuxer = transmuxerPlugin();
  663.           this.transmuxers_.set(contentType, transmuxer);
  664.           mimeType =
  665.               transmuxer.convertCodecs(contentType, mimeTypeWithAllCodecs);
  666.         }
  667.       }
  668.       const type = this.addExtraFeaturesToMimeType_(mimeType);
  670.       this.destroyer_.ensureNotDestroyed();
  672.       let sourceBuffer;
  674.       try {
  675.         sourceBuffer = this.mediaSource_.addSourceBuffer(type);
  676.       } catch (exception) {
  677.         throw new shaka.util.Error(
  678.             shaka.util.Error.Severity.CRITICAL,
  679.             shaka.util.Error.Category.MEDIA,
  680.             shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  681.             exception,
  682.             'The mediaSource_ status was ' + this.mediaSource_.readyState +
  683.             ' expected \'open\'',
  684.             null);
  685.       }
  687.       if (this.sequenceMode_) {
  688.         sourceBuffer.mode =
  689.             shaka.media.MediaSourceEngine.SourceBufferMode_.SEQUENCE;
  690.       }
  692.       this.eventManager_.listen(
  693.           sourceBuffer, 'error',
  694.           () => this.onError_(contentType));
  695.       this.eventManager_.listen(
  696.           sourceBuffer, 'updateend',
  697.           () => this.onUpdateEnd_(contentType));
  698.       this.sourceBuffers_.set(contentType, sourceBuffer);
  699.       this.sourceBufferTypes_.set(contentType, mimeType);
  700.       this.expectedEncryption_.set(contentType, !!stream.drmInfos.length);
  701.     }
  702.   }
  704.   /**
  705.    * Called by the Player to provide an updated configuration any time it
  706.    * changes. Must be called at least once before init().
  707.    *
  708.    * @param {shaka.extern.MediaSourceConfiguration} config
  709.    */
  710.   configure(config) {
  711.     this.config_ = config;
  712.     if (this.textEngine_) {
  713.       this.textEngine_.setModifyCueCallback(config.modifyCueCallback);
  714.     }
  715.   }
  717.   /**
  718.    * Indicate if the streaming is allowed by MediaSourceEngine.
  719.    * If we using MediaSource we always returns true.
  720.    *
  721.    * @return {boolean}
  722.    */
  723.   isStreamingAllowed() {
  724.     return this.streamingAllowed_ && !this.usingRemotePlayback_ &&
  725.         !this.reloadingMediaSource_;
  726.   }
  728.   /**
  729.    * Reinitialize the TextEngine for a new text type.
  730.    * @param {string} mimeType
  731.    * @param {boolean} sequenceMode
  732.    * @param {boolean} external
  733.    */
  734.   reinitText(mimeType, sequenceMode, external) {
  735.     if (!this.textEngine_) {
  736.       this.textEngine_ = new shaka.text.TextEngine(this.textDisplayer_);
  737.       if (this.textEngine_) {
  738.         this.textEngine_.setModifyCueCallback(this.config_.modifyCueCallback);
  739.       }
  740.     }
  741.     this.textEngine_.initParser(mimeType, sequenceMode,
  742.         external || this.segmentRelativeVttTiming_, this.manifestType_);
  743.   }
  745.   /**
  746.    * @return {boolean} True if the MediaSource is in an "ended" state, or if the
  747.    *   object has been destroyed.
  748.    */
  749.   ended() {
  750.     if (this.reloadingMediaSource_) {
  751.       return false;
  752.     }
  753.     return this.mediaSource_ ? this.mediaSource_.readyState == 'ended' : true;
  754.   }
  756.   /**
  757.    * @return {boolean} True if the MediaSource is in an "closed" state, or if
  758.    *   the object has been destroyed.
  759.    */
  760.   closed() {
  761.     if (this.reloadingMediaSource_) {
  762.       return false;
  763.     }
  764.     return this.mediaSource_ ? this.mediaSource_.readyState == 'closed' : true;
  765.   }
  767.   /**
  768.    * Gets the first timestamp in buffer for the given content type.
  769.    *
  770.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  771.    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  772.    */
  773.   bufferStart(contentType) {
  774.     if (!this.sourceBuffers_.size) {
  775.       return null;
  776.     }
  777.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  778.     if (contentType == ContentType.TEXT) {
  779.       return this.textEngine_.bufferStart();
  780.     }
  781.     return shaka.media.TimeRangesUtils.bufferStart(
  782.         this.getBuffered_(contentType));
  783.   }
  785.   /**
  786.    * Gets the last timestamp in buffer for the given content type.
  787.    *
  788.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  789.    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  790.    */
  791.   bufferEnd(contentType) {
  792.     if (!this.sourceBuffers_.size) {
  793.       return null;
  794.     }
  795.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  796.     if (contentType == ContentType.TEXT) {
  797.       return this.textEngine_.bufferEnd();
  798.     }
  799.     return shaka.media.TimeRangesUtils.bufferEnd(
  800.         this.getBuffered_(contentType));
  801.   }
  803.   /**
  804.    * Determines if the given time is inside the buffered range of the given
  805.    * content type.
  806.    *
  807.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  808.    * @param {number} time Playhead time
  809.    * @return {boolean}
  810.    */
  811.   isBuffered(contentType, time) {
  812.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  813.     if (contentType == ContentType.TEXT) {
  814.       return this.textEngine_.isBuffered(time);
  815.     } else {
  816.       const buffered = this.getBuffered_(contentType);
  817.       return shaka.media.TimeRangesUtils.isBuffered(buffered, time);
  818.     }
  819.   }
  821.   /**
  822.    * Computes how far ahead of the given timestamp is buffered for the given
  823.    * content type.
  824.    *
  825.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  826.    * @param {number} time
  827.    * @return {number} The amount of time buffered ahead in seconds.
  828.    */
  829.   bufferedAheadOf(contentType, time) {
  830.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  831.     if (contentType == ContentType.TEXT) {
  832.       return this.textEngine_.bufferedAheadOf(time);
  833.     } else {
  834.       const buffered = this.getBuffered_(contentType);
  835.       return shaka.media.TimeRangesUtils.bufferedAheadOf(buffered, time);
  836.     }
  837.   }
  839.   /**
  840.    * Returns info about what is currently buffered.
  841.    * @return {shaka.extern.BufferedInfo}
  842.    */
  843.   getBufferedInfo() {
  844.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  845.     const TimeRangesUtils = shaka.media.TimeRangesUtils;
  847.     const info = {
  848.       total: this.reloadingMediaSource_ ? [] :
  849.         TimeRangesUtils.getBufferedInfo(this.video_.buffered),
  850.       audio:
  851.         TimeRangesUtils.getBufferedInfo(this.getBuffered_(ContentType.AUDIO)),
  852.       video:
  853.         TimeRangesUtils.getBufferedInfo(this.getBuffered_(ContentType.VIDEO)),
  854.       text: [],
  855.     };
  857.     if (this.textEngine_) {
  858.       const start = this.textEngine_.bufferStart();
  859.       const end = this.textEngine_.bufferEnd();
  861.       if (start != null && end != null) {
  862.         info.text.push({start: start, end: end});
  863.       }
  864.     }
  865.     return info;
  866.   }
  868.   /**
  869.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  870.    * @return {TimeRanges} The buffered ranges for the given content type, or
  871.    *   null if the buffered ranges could not be obtained.
  872.    * @private
  873.    */
  874.   getBuffered_(contentType) {
  875.     if (this.reloadingMediaSource_ || this.usingRemotePlayback_) {
  876.       return null;
  877.     }
  878.     try {
  879.       return this.sourceBuffers_.get(contentType).buffered;
  880.     } catch (exception) {
  881.       if (this.sourceBuffers_.has(contentType)) {
  882.         // Note: previous MediaSource errors may cause access to |buffered| to
  883.         // throw.
  884.         shaka.log.error('failed to get buffered range for ' + contentType,
  885.             exception);
  886.       }
  887.       return null;
  888.     }
  889.   }
  891.   /**
  892.    * Create a new closed caption parser. This will ONLY be replaced by tests as
  893.    * a way to inject fake closed caption parser instances.
  894.    *
  895.    * @param {string} mimeType
  896.    * @return {!shaka.media.IClosedCaptionParser}
  897.    */
  898.   getCaptionParser(mimeType) {
  899.     return new shaka.media.ClosedCaptionParser(mimeType);
  900.   }
  902.   /**
  903.    * This method is only public for testing.
  904.    *
  905.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  906.    * @param {!BufferSource} data
  907.    * @param {!shaka.media.SegmentReference} reference The segment reference
  908.    *   we are appending
  909.    * @param {shaka.extern.Stream} stream
  910.    * @param {!string} mimeType
  911.    * @return {{timestamp: ?number, metadata: !Array<shaka.extern.ID3Metadata>}}
  912.    */
  913.   getTimestampAndDispatchMetadata(contentType, data, reference, stream,
  914.       mimeType) {
  915.     let timestamp = null;
  916.     let metadata = [];
  918.     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
  919.     if (shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType)) {
  920.       const frames = shaka.util.Id3Utils.getID3Frames(uint8ArrayData);
  921.       if (frames.length && reference) {
  922.         const metadataTimestamp = frames.find((frame) => {
  923.           return frame.description ===
  924.               'com.apple.streaming.transportStreamTimestamp';
  925.         });
  926.         if (metadataTimestamp) {
  927.           timestamp = Math.round(metadataTimestamp.data) / 1000;
  928.         }
  929.         /** @private {shaka.extern.ID3Metadata} */
  930.         const id3Metadata = {
  931.           cueTime: reference.startTime,
  932.           data: uint8ArrayData,
  933.           frames: frames,
  934.           dts: reference.startTime,
  935.           pts: reference.startTime,
  936.         };
  937.         this.playerInterface_.onMetadata(
  938.             [id3Metadata], /* offset= */ 0, reference.endTime);
  939.       }
  940.     } else if (mimeType.includes('/mp4') &&
  941.         reference &&
  942.         reference.initSegmentReference &&
  943.         reference.initSegmentReference.timescale) {
  944.       const timescale = reference.initSegmentReference.timescale;
  945.       if (!isNaN(timescale)) {
  946.         const hasEmsg = ((stream.emsgSchemeIdUris != null &&
  947.             stream.emsgSchemeIdUris.length > 0) ||
  948.             this.config_.dispatchAllEmsgBoxes);
  949.         const Mp4Parser = shaka.util.Mp4Parser;
  950.         let startTime = 0;
  951.         let parsedMedia = false;
  952.         const parser = new Mp4Parser();
  953.         if (hasEmsg) {
  954.           parser.fullBox('emsg', (box) =>
  955.             this.parseEMSG_(reference, stream.emsgSchemeIdUris, box));
  956.         }
  957.         parser.fullBox('prft', (box) => this.parsePrft_(timescale, box))
  958.             .box('moof', Mp4Parser.children)
  959.             .box('traf', Mp4Parser.children)
  960.             .fullBox('tfdt', (box) => {
  961.               if (!parsedMedia) {
  962.                 goog.asserts.assert(
  963.                     box.version == 0 || box.version == 1,
  964.                     'TFDT version can only be 0 or 1');
  965.                 const parsed = shaka.util.Mp4BoxParsers.parseTFDTInaccurate(
  966.                     box.reader, box.version);
  967.                 startTime = parsed.baseMediaDecodeTime / timescale;
  968.                 parsedMedia = true;
  969.                 if (!hasEmsg) {
  970.                   box.parser.stop();
  971.                 }
  972.               }
  973.             }).parse(data, /* partialOkay= */ true);
  974.         if (parsedMedia && reference.timestampOffset == 0) {
  975.           timestamp = startTime;
  976.         }
  977.       }
  978.     } else if (!mimeType.includes('/mp4') && !mimeType.includes('/webm') &&
  979.         shaka.util.TsParser.probe(uint8ArrayData)) {
  980.       if (!this.tsParsers_.has(contentType)) {
  981.         this.tsParsers_.set(contentType, new shaka.util.TsParser());
  982.       } else {
  983.         this.tsParsers_.get(contentType).clearData();
  984.       }
  985.       const tsParser = this.tsParsers_.get(contentType).parse(uint8ArrayData);
  986.       const startTime = tsParser.getStartTime(contentType);
  987.       if (startTime != null) {
  988.         timestamp = startTime;
  989.       }
  990.       metadata = tsParser.getMetadata();
  991.     }
  992.     return {timestamp, metadata};
  993.   }
  996.   /**
  997.    * Parse the EMSG box from a MP4 container.
  998.    *
  999.    * @param {!shaka.media.SegmentReference} reference
  1000.    * @param {?Array<string>} emsgSchemeIdUris Array of emsg
  1001.    *     scheme_id_uri for which emsg boxes should be parsed.
  1002.    * @param {!shaka.extern.ParsedBox} box
  1003.    * @private
  1004.    * https://dashif-documents.azurewebsites.net/Events/master/event.html#emsg-format
  1005.    * aligned(8) class DASHEventMessageBox
  1006.    *    extends FullBox(‘emsg’, version, flags = 0){
  1007.    * if (version==0) {
  1008.    *   string scheme_id_uri;
  1009.    *   string value;
  1010.    *   unsigned int(32) timescale;
  1011.    *   unsigned int(32) presentation_time_delta;
  1012.    *   unsigned int(32) event_duration;
  1013.    *   unsigned int(32) id;
  1014.    * } else if (version==1) {
  1015.    *   unsigned int(32) timescale;
  1016.    *   unsigned int(64) presentation_time;
  1017.    *   unsigned int(32) event_duration;
  1018.    *   unsigned int(32) id;
  1019.    *   string scheme_id_uri;
  1020.    *   string value;
  1021.    * }
  1022.    * unsigned int(8) message_data[];
  1023.    */
  1024.   parseEMSG_(reference, emsgSchemeIdUris, box) {
  1025.     let timescale;
  1026.     let id;
  1027.     let eventDuration;
  1028.     let schemeId;
  1029.     let startTime;
  1030.     let presentationTimeDelta;
  1031.     let value;
  1033.     if (box.version === 0) {
  1034.       schemeId = box.reader.readTerminatedString();
  1035.       value = box.reader.readTerminatedString();
  1036.       timescale = box.reader.readUint32();
  1037.       presentationTimeDelta = box.reader.readUint32();
  1038.       eventDuration = box.reader.readUint32();
  1039.       id = box.reader.readUint32();
  1040.       startTime = reference.startTime + (presentationTimeDelta / timescale);
  1041.     } else {
  1042.       timescale = box.reader.readUint32();
  1043.       const pts = box.reader.readUint64();
  1044.       startTime = (pts / timescale) + reference.timestampOffset;
  1045.       presentationTimeDelta = startTime - reference.startTime;
  1046.       eventDuration = box.reader.readUint32();
  1047.       id = box.reader.readUint32();
  1048.       schemeId = box.reader.readTerminatedString();
  1049.       value = box.reader.readTerminatedString();
  1050.     }
  1051.     const messageData = box.reader.readBytes(
  1052.         box.reader.getLength() - box.reader.getPosition());
  1054.     // See DASH sec. 5.10.3.3.1
  1055.     // If a DASH client detects an event message box with a scheme that is not
  1056.     // defined in MPD, the client is expected to ignore it.
  1057.     if ((emsgSchemeIdUris && emsgSchemeIdUris.includes(schemeId)) ||
  1058.         this.config_.dispatchAllEmsgBoxes) {
  1059.       // See DASH sec. 5.10.4.1
  1060.       // A special scheme in DASH used to signal manifest updates.
  1061.       if (schemeId == 'urn:mpeg:dash:event:2012') {
  1062.         this.playerInterface_.onManifestUpdate();
  1063.       } else {
  1064.         // All other schemes are dispatched as a general 'emsg' event.
  1065.         const endTime = startTime + (eventDuration / timescale);
  1066.         /** @type {shaka.extern.EmsgInfo} */
  1067.         const emsg = {
  1068.           startTime: startTime,
  1069.           endTime: endTime,
  1070.           schemeIdUri: schemeId,
  1071.           value: value,
  1072.           timescale: timescale,
  1073.           presentationTimeDelta: presentationTimeDelta,
  1074.           eventDuration: eventDuration,
  1075.           id: id,
  1076.           messageData: messageData,
  1077.         };
  1079.         // Dispatch an event to notify the application about the emsg box.
  1080.         const eventName = shaka.util.FakeEvent.EventName.Emsg;
  1081.         const data = (new Map()).set('detail', emsg);
  1082.         const event = new shaka.util.FakeEvent(eventName, data);
  1083.         // A user can call preventDefault() on a cancelable event.
  1084.         event.cancelable = true;
  1086.         this.playerInterface_.onEmsg(emsg);
  1088.         // Additionally, ID3 events generate a 'metadata' event.  This is a
  1089.         // pre-parsed version of the metadata blob already dispatched in the
  1090.         // 'emsg' event.
  1091.         if (schemeId == 'https://aomedia.org/emsg/ID3' ||
  1092.             schemeId == 'https://developer.apple.com/streaming/emsg-id3') {
  1093.           // See https://aomediacodec.github.io/id3-emsg/
  1094.           const frames = shaka.util.Id3Utils.getID3Frames(messageData);
  1095.           if (frames.length) {
  1096.             /** @private {shaka.extern.ID3Metadata} */
  1097.             const metadata = {
  1098.               cueTime: startTime,
  1099.               data: messageData,
  1100.               frames: frames,
  1101.               dts: startTime,
  1102.               pts: startTime,
  1103.             };
  1104.             this.playerInterface_.onMetadata(
  1105.                 [metadata], /* offset= */ 0, endTime);
  1106.           }
  1107.         }
  1108.       }
  1109.     }
  1110.   }
  1112.   /**
  1113.    * Parse PRFT box.
  1114.    * @param {number} timescale
  1115.    * @param {!shaka.extern.ParsedBox} box
  1116.    * @private
  1117.    */
  1118.   parsePrft_(timescale, box) {
  1119.     goog.asserts.assert(
  1120.         box.version == 0 || box.version == 1,
  1121.         'PRFT version can only be 0 or 1');
  1122.     const parsed = shaka.util.Mp4BoxParsers.parsePRFTInaccurate(
  1123.         box.reader, box.version);
  1125.     const wallClockTime = this.convertNtp_(parsed.ntpTimestamp);
  1126.     const programStartDate = new Date(wallClockTime -
  1127.       (parsed.mediaTime / timescale) * 1000);
  1128.     /** @type {shaka.extern.ProducerReferenceTime} */
  1129.     const prftInfo = {
  1130.       wallClockTime,
  1131.       programStartDate,
  1132.     };
  1134.     const eventName = shaka.util.FakeEvent.EventName.Prft;
  1135.     const data = (new Map()).set('detail', prftInfo);
  1136.     const event = new shaka.util.FakeEvent(
  1137.         eventName, data);
  1138.     this.playerInterface_.onEvent(event);
  1139.   }
  1142.   /**
  1143.    * Convert Ntp ntpTimeStamp to UTC Time
  1144.    *
  1145.    * @param {number} ntpTimeStamp
  1146.    * @return {number} utcTime
  1147.    * @private
  1148.    */
  1149.   convertNtp_(ntpTimeStamp) {
  1150.     const start = new Date(Date.UTC(1900, 0, 1, 0, 0, 0));
  1151.     return new Date(start.getTime() + ntpTimeStamp).getTime();
  1152.   }
  1154.   /**
  1155.    * Enqueue an operation to append data to the SourceBuffer.
  1156.    * Start and end times are needed for TextEngine, but not for MediaSource.
  1157.    * Start and end times may be null for initialization segments; if present
  1158.    * they are relative to the presentation timeline.
  1159.    *
  1160.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1161.    * @param {!BufferSource} data
  1162.    * @param {?shaka.media.SegmentReference} reference The segment reference
  1163.    *   we are appending, or null for init segments
  1164.    * @param {shaka.extern.Stream} stream
  1165.    * @param {?boolean} hasClosedCaptions True if the buffer contains CEA closed
  1166.    *   captions
  1167.    * @param {boolean=} seeked True if we just seeked
  1168.    * @param {boolean=} adaptation True if we just automatically switched active
  1169.    *   variant(s).
  1170.    * @param {boolean=} isChunkedData True if we add to the buffer from the
  1171.    *   partial read of the segment.
  1172.    * @return {!Promise}
  1173.    */
  1174.   async appendBuffer(
  1175.       contentType, data, reference, stream, hasClosedCaptions, seeked = false,
  1176.       adaptation = false, isChunkedData = false, fromSplit = false) {
  1177.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1179.     if (contentType == ContentType.TEXT) {
  1180.       if (this.manifestType_ == shaka.media.ManifestParser.HLS) {
  1181.         // This won't be known until the first video segment is appended.
  1182.         const offset = await this.textSequenceModeOffset_;
  1183.         this.textEngine_.setTimestampOffset(offset);
  1184.       }
  1185.       await this.textEngine_.appendBuffer(
  1186.           data,
  1187.           reference ? reference.startTime : null,
  1188.           reference ? reference.endTime : null,
  1189.           reference ? reference.getUris()[0] : null);
  1190.       return;
  1191.     }
  1193.     if (!fromSplit && this.needSplitMuxedContent_) {
  1194.       await this.appendBuffer(ContentType.AUDIO, data, reference, stream,
  1195.           hasClosedCaptions, seeked, adaptation, isChunkedData,
  1196.           /* fromSplit= */ true);
  1197.       await this.appendBuffer(ContentType.VIDEO, data, reference, stream,
  1198.           hasClosedCaptions, seeked, adaptation, isChunkedData,
  1199.           /* fromSplit= */ true);
  1200.       return;
  1201.     }
  1203.     if (!this.sourceBuffers_.has(contentType)) {
  1204.       shaka.log.warning('Attempted to restore a non-existent source buffer');
  1205.       return;
  1206.     }
  1208.     let timestampOffset = this.sourceBuffers_.get(contentType).timestampOffset;
  1210.     let mimeType = this.sourceBufferTypes_.get(contentType);
  1211.     if (this.transmuxers_.has(contentType)) {
  1212.       mimeType = this.transmuxers_.get(contentType).getOriginalMimeType();
  1213.     }
  1214.     if (reference) {
  1215.       const {timestamp, metadata} = this.getTimestampAndDispatchMetadata(
  1216.           contentType, data, reference, stream, mimeType);
  1217.       if (timestamp != null) {
  1218.         if (this.firstVideoTimestamp_ == null &&
  1219.             contentType == ContentType.VIDEO) {
  1220.           this.firstVideoTimestamp_ = timestamp;
  1221.           this.firstVideoReferenceStartTime_ = reference.startTime;
  1222.           if (this.firstAudioTimestamp_ != null) {
  1223.             let compensation = 0;
  1224.             // Only apply compensation if video and audio segment startTime
  1225.             // match, to avoid introducing sync issues.
  1226.             if (this.firstVideoReferenceStartTime_ ==
  1227.                 this.firstAudioReferenceStartTime_) {
  1228.               compensation =
  1229.                   this.firstVideoTimestamp_ - this.firstAudioTimestamp_;
  1230.             }
  1231.             this.audioCompensation_.resolve(compensation);
  1232.           }
  1233.         }
  1234.         if (this.firstAudioTimestamp_ == null &&
  1235.             contentType == ContentType.AUDIO) {
  1236.           this.firstAudioTimestamp_ = timestamp;
  1237.           this.firstAudioReferenceStartTime_ = reference.startTime;
  1238.           if (this.firstVideoTimestamp_ != null) {
  1239.             let compensation = 0;
  1240.             // Only apply compensation if video and audio segment startTime
  1241.             // match, to avoid introducing sync issues.
  1242.             if (this.firstVideoReferenceStartTime_ ==
  1243.                 this.firstAudioReferenceStartTime_) {
  1244.               compensation =
  1245.                   this.firstVideoTimestamp_ - this.firstAudioTimestamp_;
  1246.             }
  1247.             this.audioCompensation_.resolve(compensation);
  1248.           }
  1249.         }
  1250.         let realTimestamp = timestamp;
  1251.         const RAW_FORMATS = shaka.util.MimeUtils.RAW_FORMATS;
  1252.         // For formats without containers and using segments mode, we need to
  1253.         // adjust TimestampOffset relative to 0 because segments do not have
  1254.         // any timestamp information.
  1255.         if (!this.sequenceMode_ &&
  1256.             RAW_FORMATS.includes(this.sourceBufferTypes_.get(contentType))) {
  1257.           realTimestamp = 0;
  1258.         }
  1259.         const calculatedTimestampOffset = reference.startTime - realTimestamp;
  1260.         const timestampOffsetDifference =
  1261.             Math.abs(timestampOffset - calculatedTimestampOffset);
  1262.         if ((timestampOffsetDifference >= 0.001 || seeked || adaptation) &&
  1263.             (!isChunkedData || calculatedTimestampOffset > 0 ||
  1264.             !timestampOffset)) {
  1265.           timestampOffset = calculatedTimestampOffset;
  1266.           if (this.attemptTimestampOffsetCalculation_) {
  1267.             this.enqueueOperation_(
  1268.                 contentType,
  1269.                 () => this.abort_(contentType),
  1270.                 null);
  1271.             this.enqueueOperation_(
  1272.                 contentType,
  1273.                 () => this.setTimestampOffset_(contentType, timestampOffset),
  1274.                 null);
  1275.           }
  1276.         }
  1277.         // Timestamps can only be reliably extracted from video, not audio.
  1278.         // Packed audio formats do not have internal timestamps at all.
  1279.         // Prefer video for this when available.
  1280.         const isBestSourceBufferForTimestamps =
  1281.             contentType == ContentType.VIDEO ||
  1282.             !(this.sourceBuffers_.has(ContentType.VIDEO));
  1283.         if (isBestSourceBufferForTimestamps) {
  1284.           this.textSequenceModeOffset_.resolve(timestampOffset);
  1285.         }
  1286.       }
  1287.       if (metadata.length) {
  1288.         this.playerInterface_.onMetadata(metadata, timestampOffset,
  1289.             reference ? reference.endTime : null);
  1290.       }
  1291.     }
  1292.     if (hasClosedCaptions && contentType == ContentType.VIDEO) {
  1293.       if (!this.textEngine_) {
  1294.         this.reinitText(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE,
  1295.             this.sequenceMode_, /* external= */ false);
  1296.       }
  1297.       if (!this.captionParser_) {
  1298.         const basicType = mimeType.split(';', 1)[0];
  1299.         this.captionParser_ = this.getCaptionParser(basicType);
  1300.       }
  1301.       // If it is the init segment for closed captions, initialize the closed
  1302.       // caption parser.
  1303.       if (!reference) {
  1304.         this.captionParser_.init(data, adaptation);
  1305.       } else {
  1306.         const closedCaptions = this.captionParser_.parseFrom(data);
  1307.         if (closedCaptions.length) {
  1308.           this.textEngine_.storeAndAppendClosedCaptions(
  1309.               closedCaptions,
  1310.               reference.startTime,
  1311.               reference.endTime,
  1312.               timestampOffset);
  1313.         }
  1314.       }
  1315.     }
  1317.     if (this.transmuxers_.has(contentType)) {
  1318.       data = await this.transmuxers_.get(contentType).transmux(
  1319.           data, stream, reference, this.mediaSource_.duration, contentType);
  1320.     }
  1322.     data = this.workAroundBrokenPlatforms_(
  1323.         stream, data, reference, contentType);
  1325.     if (reference && this.sequenceMode_ && contentType != ContentType.TEXT) {
  1326.       // In sequence mode, for non-text streams, if we just cleared the buffer
  1327.       // and are either performing an unbuffered seek or handling an automatic
  1328.       // adaptation, we need to set a new timestampOffset on the sourceBuffer.
  1329.       if (seeked || adaptation) {
  1330.         let timestampOffset = reference.startTime;
  1331.         // Audio and video may not be aligned, so we will compensate for audio
  1332.         // if necessary.
  1333.         if (this.manifestType_ == shaka.media.ManifestParser.HLS &&
  1334.             !this.needSplitMuxedContent_ &&
  1335.             contentType == ContentType.AUDIO &&
  1336.             this.sourceBuffers_.has(ContentType.VIDEO)) {
  1337.           const compensation = await this.audioCompensation_;
  1338.           // Only apply compensation if the difference is greater than 150ms
  1339.           if (Math.abs(compensation) > 0.15) {
  1340.             timestampOffset -= compensation;
  1341.           }
  1342.         }
  1343.         // The logic to call abort() before setting the timestampOffset is
  1344.         // extended during unbuffered seeks or automatic adaptations; it is
  1345.         // possible for the append state to be PARSING_MEDIA_SEGMENT from the
  1346.         // previous SourceBuffer#appendBuffer() call.
  1347.         this.enqueueOperation_(
  1348.             contentType,
  1349.             () => this.abort_(contentType),
  1350.             null);
  1351.         this.enqueueOperation_(
  1352.             contentType,
  1353.             () => this.setTimestampOffset_(contentType, timestampOffset),
  1354.             null);
  1355.       }
  1356.     }
  1358.     let bufferedBefore = null;
  1360.     await this.enqueueOperation_(contentType, () => {
  1361.       if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
  1362.         bufferedBefore = this.getBuffered_(contentType);
  1363.       }
  1364.       this.append_(contentType, data, timestampOffset, stream);
  1365.     }, reference ? reference.getUris()[0] : null);
  1367.     if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
  1368.       const bufferedAfter = this.getBuffered_(contentType);
  1369.       const newBuffered = shaka.media.TimeRangesUtils.computeAddedRange(
  1370.           bufferedBefore, bufferedAfter);
  1371.       if (newBuffered) {
  1372.         const segmentDuration = reference.endTime - reference.startTime;
  1373.         const timeAdded = newBuffered.end - newBuffered.start;
  1374.         // Check end times instead of start times.  We may be overwriting a
  1375.         // buffer and only the end changes, and that would be fine.
  1376.         // Also, exclude tiny segments.  Sometimes alignment segments as small
  1377.         // as 33ms are seen in Google DAI content.  For such tiny segments,
  1378.         // half a segment duration would be no issue.
  1379.         const offset = Math.abs(newBuffered.end - reference.endTime);
  1380.         if (segmentDuration > 0.100 && (offset > segmentDuration / 2 ||
  1381.             Math.abs(segmentDuration - timeAdded) > 0.030)) {
  1382.           shaka.log.error('Possible encoding problem detected!',
  1383.               'Unexpected buffered range for reference', reference,
  1384.               'from URIs', reference.getUris(),
  1385.               'should be', {start: reference.startTime, end: reference.endTime},
  1386.               'but got', newBuffered);
  1387.         }
  1388.       }
  1389.     }
  1390.   }
  1392.   /**
  1393.    * Set the selected closed captions Id and language.
  1394.    *
  1395.    * @param {string} id
  1396.    */
  1397.   setSelectedClosedCaptionId(id) {
  1398.     const VIDEO = shaka.util.ManifestParserUtils.ContentType.VIDEO;
  1399.     const videoBufferEndTime = this.bufferEnd(VIDEO) || 0;
  1400.     this.textEngine_.setSelectedClosedCaptionId(id, videoBufferEndTime);
  1401.   }
  1403.   /** Disable embedded closed captions. */
  1404.   clearSelectedClosedCaptionId() {
  1405.     if (this.textEngine_) {
  1406.       this.textEngine_.setSelectedClosedCaptionId('', 0);
  1407.     }
  1408.   }
  1410.   /**
  1411.    * Enqueue an operation to remove data from the SourceBuffer.
  1412.    *
  1413.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1414.    * @param {number} startTime relative to the start of the presentation
  1415.    * @param {number} endTime relative to the start of the presentation
  1416.    * @return {!Promise}
  1417.    */
  1418.   async remove(contentType, startTime, endTime) {
  1419.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1420.     if (contentType == ContentType.TEXT) {
  1421.       await this.textEngine_.remove(startTime, endTime);
  1422.     } else if (endTime > startTime) {
  1423.       await this.enqueueOperation_(
  1424.           contentType,
  1425.           () => this.remove_(contentType, startTime, endTime),
  1426.           null);
  1427.       if (this.needSplitMuxedContent_) {
  1428.         await this.enqueueOperation_(
  1429.             ContentType.AUDIO,
  1430.             () => this.remove_(ContentType.AUDIO, startTime, endTime),
  1431.             null);
  1432.       }
  1433.     }
  1434.   }
  1436.   /**
  1437.    * Enqueue an operation to clear the SourceBuffer.
  1438.    *
  1439.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1440.    * @return {!Promise}
  1441.    */
  1442.   async clear(contentType) {
  1443.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1444.     if (contentType == ContentType.TEXT) {
  1445.       if (!this.textEngine_) {
  1446.         return;
  1447.       }
  1448.       await this.textEngine_.remove(0, Infinity);
  1449.     } else {
  1450.       // Note that not all platforms allow clearing to Infinity.
  1451.       await this.enqueueOperation_(
  1452.           contentType,
  1453.           () => this.remove_(contentType, 0, this.mediaSource_.duration),
  1454.           null);
  1455.       if (this.needSplitMuxedContent_) {
  1456.         await this.enqueueOperation_(
  1457.             ContentType.AUDIO,
  1458.             () => this.remove_(
  1459.                 ContentType.AUDIO, 0, this.mediaSource_.duration),
  1460.             null);
  1461.       }
  1462.     }
  1463.   }
  1465.   /**
  1466.    * Fully reset the state of the caption parser owned by MediaSourceEngine.
  1467.    */
  1468.   resetCaptionParser() {
  1469.     if (this.captionParser_) {
  1470.       this.captionParser_.reset();
  1471.     }
  1472.   }
  1474.   /**
  1475.    * Enqueue an operation to flush the SourceBuffer.
  1476.    * This is a workaround for what we believe is a Chromecast bug.
  1477.    *
  1478.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1479.    * @return {!Promise}
  1480.    */
  1481.   async flush(contentType) {
  1482.     // Flush the pipeline.  Necessary on Chromecast, even though we have removed
  1483.     // everything.
  1484.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1485.     if (contentType == ContentType.TEXT) {
  1486.       // Nothing to flush for text.
  1487.       return;
  1488.     }
  1489.     await this.enqueueOperation_(
  1490.         contentType,
  1491.         () => this.flush_(contentType),
  1492.         null);
  1493.     if (this.needSplitMuxedContent_) {
  1494.       await this.enqueueOperation_(
  1495.           ContentType.AUDIO,
  1496.           () => this.flush_(ContentType.AUDIO),
  1497.           null);
  1498.     }
  1499.   }
  1501.   /**
  1502.    * Sets the timestamp offset and append window end for the given content type.
  1503.    *
  1504.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1505.    * @param {number} timestampOffset The timestamp offset.  Segments which start
  1506.    *   at time t will be inserted at time t + timestampOffset instead.  This
  1507.    *   value does not affect segments which have already been inserted.
  1508.    * @param {number} appendWindowStart The timestamp to set the append window
  1509.    *   start to.  For future appends, frames/samples with timestamps less than
  1510.    *   this value will be dropped.
  1511.    * @param {number} appendWindowEnd The timestamp to set the append window end
  1512.    *   to.  For future appends, frames/samples with timestamps greater than this
  1513.    *   value will be dropped.
  1514.    * @param {boolean} ignoreTimestampOffset  If true, the timestampOffset will
  1515.    *   not be applied in this step.
  1516.    * @param {string} mimeType
  1517.    * @param {string} codecs
  1518.    * @param {!Map<shaka.util.ManifestParserUtils.ContentType,
  1519.    *               shaka.extern.Stream>} streamsByType
  1520.    *   A map of content types to streams.  All streams must be supported
  1521.    *   according to MediaSourceEngine.isStreamSupported.
  1522.    *
  1523.    * @return {!Promise}
  1524.    */
  1525.   async setStreamProperties(
  1526.       contentType, timestampOffset, appendWindowStart, appendWindowEnd,
  1527.       ignoreTimestampOffset, mimeType, codecs, streamsByType) {
  1528.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1529.     if (contentType == ContentType.TEXT) {
  1530.       if (!ignoreTimestampOffset) {
  1531.         this.textEngine_.setTimestampOffset(timestampOffset);
  1532.       }
  1533.       this.textEngine_.setAppendWindow(appendWindowStart, appendWindowEnd);
  1534.       return;
  1535.     }
  1536.     const operations = [];
  1538.     const hasChangedCodecs = await this.codecSwitchIfNecessary_(
  1539.         contentType, mimeType, codecs, streamsByType);
  1541.     if (!hasChangedCodecs) {
  1542.       // Queue an abort() to help MSE splice together overlapping segments.
  1543.       // We set appendWindowEnd when we change periods in DASH content, and the
  1544.       // period transition may result in overlap.
  1545.       //
  1546.       // An abort() also helps with MPEG2-TS.  When we append a TS segment, we
  1547.       // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
  1548.       // timestamp offset.  By calling abort(), we reset the state so we can
  1549.       // set it.
  1550.       operations.push(this.enqueueOperation_(
  1551.           contentType,
  1552.           () => this.abort_(contentType),
  1553.           null));
  1554.       if (this.needSplitMuxedContent_) {
  1555.         operations.push(this.enqueueOperation_(
  1556.             ContentType.AUDIO,
  1557.             () => this.abort_(ContentType.AUDIO),
  1558.             null));
  1559.       }
  1560.     }
  1561.     if (!ignoreTimestampOffset) {
  1562.       operations.push(this.enqueueOperation_(
  1563.           contentType,
  1564.           () => this.setTimestampOffset_(contentType, timestampOffset),
  1565.           null));
  1566.       if (this.needSplitMuxedContent_) {
  1567.         operations.push(this.enqueueOperation_(
  1568.             ContentType.AUDIO,
  1569.             () => this.setTimestampOffset_(
  1570.                 ContentType.AUDIO, timestampOffset),
  1571.             null));
  1572.       }
  1573.     }
  1574.     if (appendWindowStart != 0 || appendWindowEnd != Infinity) {
  1575.       operations.push(this.enqueueOperation_(
  1576.           contentType,
  1577.           () => this.setAppendWindow_(
  1578.               contentType, appendWindowStart, appendWindowEnd),
  1579.           null));
  1580.       if (this.needSplitMuxedContent_) {
  1581.         operations.push(this.enqueueOperation_(
  1582.             ContentType.AUDIO,
  1583.             () => this.setAppendWindow_(
  1584.                 ContentType.AUDIO, appendWindowStart, appendWindowEnd),
  1585.             null));
  1586.       }
  1587.     }
  1589.     if (operations.length) {
  1590.       await Promise.all(operations);
  1591.     }
  1592.   }
  1594.   /**
  1595.    * Adjust timestamp offset to maintain AV sync across discontinuities.
  1596.    *
  1597.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1598.    * @param {number} timestampOffset
  1599.    * @return {!Promise}
  1600.    */
  1601.   async resync(contentType, timestampOffset) {
  1602.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1604.     if (contentType == ContentType.TEXT) {
  1605.       // This operation is for audio and video only.
  1606.       return;
  1607.     }
  1609.     // Reset the promise in case the timestamp offset changed during
  1610.     // a period/discontinuity transition.
  1611.     if (contentType == ContentType.VIDEO) {
  1612.       this.textSequenceModeOffset_ = new shaka.util.PublicPromise();
  1613.     }
  1615.     if (!this.sequenceMode_) {
  1616.       return;
  1617.     }
  1619.     // Avoid changing timestampOffset when the difference is less than 100 ms
  1620.     // from the end of the current buffer.
  1621.     const bufferEnd = this.bufferEnd(contentType);
  1622.     if (bufferEnd && Math.abs(bufferEnd - timestampOffset) < 0.1) {
  1623.       return;
  1624.     }
  1626.     // Queue an abort() to help MSE splice together overlapping segments.
  1627.     // We set appendWindowEnd when we change periods in DASH content, and the
  1628.     // period transition may result in overlap.
  1629.     //
  1630.     // An abort() also helps with MPEG2-TS.  When we append a TS segment, we
  1631.     // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
  1632.     // timestamp offset.  By calling abort(), we reset the state so we can
  1633.     // set it.
  1634.     this.enqueueOperation_(
  1635.         contentType,
  1636.         () => this.abort_(contentType),
  1637.         null);
  1638.     if (this.needSplitMuxedContent_) {
  1639.       this.enqueueOperation_(
  1640.           ContentType.AUDIO,
  1641.           () => this.abort_(ContentType.AUDIO),
  1642.           null);
  1643.     }
  1644.     await this.enqueueOperation_(
  1645.         contentType,
  1646.         () => this.setTimestampOffset_(contentType, timestampOffset),
  1647.         null);
  1648.     if (this.needSplitMuxedContent_) {
  1649.       await this.enqueueOperation_(
  1650.           ContentType.AUDIO,
  1651.           () => this.setTimestampOffset_(ContentType.AUDIO, timestampOffset),
  1652.           null);
  1653.     }
  1654.   }
  1656.   /**
  1657.    * @param {string=} reason Valid reasons are 'network' and 'decode'.
  1658.    * @return {!Promise}
  1659.    * @see http://w3c.github.io/media-source/#idl-def-EndOfStreamError
  1660.    */
  1661.   async endOfStream(reason) {
  1662.     await this.enqueueBlockingOperation_(() => {
  1663.       // If endOfStream() has already been called on the media source,
  1664.       // don't call it again. Also do not call if readyState is
  1665.       // 'closed' (not attached to video element) since it is not a
  1666.       // valid operation.
  1667.       if (this.ended() || this.closed()) {
  1668.         return;
  1669.       }
  1670.       // Tizen won't let us pass undefined, but it will let us omit the
  1671.       // argument.
  1672.       if (reason) {
  1673.         this.mediaSource_.endOfStream(reason);
  1674.       } else {
  1675.         this.mediaSource_.endOfStream();
  1676.       }
  1677.     });
  1678.   }
  1680.   /**
  1681.    * @param {number} duration
  1682.    * @return {!Promise}
  1683.    */
  1684.   async setDuration(duration) {
  1685.     await this.enqueueBlockingOperation_(() => {
  1686.       // Reducing the duration causes the MSE removal algorithm to run, which
  1687.       // triggers an 'updateend' event to fire.  To handle this scenario, we
  1688.       // have to insert a dummy operation into the beginning of each queue,
  1689.       // which the 'updateend' handler will remove.
  1690.       if (duration < this.mediaSource_.duration) {
  1691.         for (const contentType of this.sourceBuffers_.keys()) {
  1692.           const dummyOperation = {
  1693.             start: () => {},
  1694.             p: new shaka.util.PublicPromise(),
  1695.             uri: null,
  1696.           };
  1697.           this.queues_.get(contentType).unshift(dummyOperation);
  1698.         }
  1699.       }
  1701.       this.mediaSource_.duration = duration;
  1702.       this.lastDuration_ = duration;
  1703.     });
  1704.   }
  1706.   /**
  1707.    * Get the current MediaSource duration.
  1708.    *
  1709.    * @return {number}
  1710.    */
  1711.   getDuration() {
  1712.     return this.mediaSource_.duration;
  1713.   }
  1715.   /**
  1716.    * Updates the live seekable range.
  1717.    *
  1718.    * @param {number} startTime
  1719.    * @param {number} endTime
  1720.    */
  1721.   async setLiveSeekableRange(startTime, endTime) {
  1722.     goog.asserts.assert('setLiveSeekableRange' in this.mediaSource_,
  1723.         'Using setLiveSeekableRange on not supported platform');
  1724.     if (this.ended() || this.closed()) {
  1725.       return;
  1726.     }
  1727.     await this.enqueueBlockingOperation_(() => {
  1728.       if (this.ended() || this.closed()) {
  1729.         return;
  1730.       }
  1731.       this.mediaSource_.setLiveSeekableRange(startTime, endTime);
  1732.     });
  1733.   }
  1735.   /**
  1736.    * Clear the current live seekable range.
  1737.    */
  1738.   async clearLiveSeekableRange() {
  1739.     goog.asserts.assert('clearLiveSeekableRange' in this.mediaSource_,
  1740.         'Using clearLiveSeekableRange on not supported platform');
  1741.     if (this.ended() || this.closed()) {
  1742.       return;
  1743.     }
  1744.     await this.enqueueBlockingOperation_(() => {
  1745.       if (this.ended() || this.closed()) {
  1746.         return;
  1747.       }
  1748.       this.mediaSource_.clearLiveSeekableRange();
  1749.     });
  1750.   }
  1752.   /**
  1753.    * Append dependency data.
  1754.    * @param {BufferSource} data
  1755.    * @param {number} timestampOffset
  1756.    * @param {shaka.extern.Stream} stream
  1757.    */
  1758.   appendDependency(data, timestampOffset, stream) {
  1759.     if (this.lcevcDec_) {
  1760.       // Append buffers to the LCEVC Dec for parsing and storing
  1761.       // of LCEVC data.
  1762.       this.lcevcDec_.appendBuffer(data, timestampOffset, stream);
  1763.     }
  1764.   }
  1766.   /**
  1767.    * Append data to the SourceBuffer.
  1768.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1769.    * @param {BufferSource} data
  1770.    * @param {number} timestampOffset
  1771.    * @param {shaka.extern.Stream} stream
  1772.    * @private
  1773.    */
  1774.   append_(contentType, data, timestampOffset, stream) {
  1775.     this.appendDependency(data, timestampOffset, stream);
  1777.     // This will trigger an 'updateend' event.
  1778.     this.sourceBuffers_.get(contentType).appendBuffer(data);
  1779.   }
  1781.   /**
  1782.    * Remove data from the SourceBuffer.
  1783.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1784.    * @param {number} startTime relative to the start of the presentation
  1785.    * @param {number} endTime relative to the start of the presentation
  1786.    * @private
  1787.    */
  1788.   remove_(contentType, startTime, endTime) {
  1789.     if (endTime <= startTime) {
  1790.       // Ignore removal of inverted or empty ranges.
  1791.       // Fake 'updateend' event to resolve the operation.
  1792.       this.onUpdateEnd_(contentType);
  1793.       return;
  1794.     }
  1796.     // This will trigger an 'updateend' event.
  1797.     this.sourceBuffers_.get(contentType).remove(startTime, endTime);
  1798.   }
  1800.   /**
  1801.    * Call abort() on the SourceBuffer.
  1802.    * This resets MSE's last_decode_timestamp on all track buffers, which should
  1803.    * trigger the splicing logic for overlapping segments.
  1804.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1805.    * @private
  1806.    */
  1807.   abort_(contentType) {
  1808.     const sourceBuffer = this.sourceBuffers_.get(contentType);
  1809.     // Save the append window, which is reset on abort().
  1810.     const appendWindowStart = sourceBuffer.appendWindowStart;
  1811.     const appendWindowEnd = sourceBuffer.appendWindowEnd;
  1813.     // This will not trigger an 'updateend' event, since nothing is happening.
  1814.     // This is only to reset MSE internals, not to abort an actual operation.
  1815.     sourceBuffer.abort();
  1817.     // Restore the append window.
  1818.     sourceBuffer.appendWindowStart = appendWindowStart;
  1819.     sourceBuffer.appendWindowEnd = appendWindowEnd;
  1821.     // Fake an 'updateend' event to resolve the operation.
  1822.     this.onUpdateEnd_(contentType);
  1823.   }
  1825.   /**
  1826.    * Nudge the playhead to force the media pipeline to be flushed.
  1827.    * This seems to be necessary on Chromecast to get new content to replace old
  1828.    * content.
  1829.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1830.    * @private
  1831.    */
  1832.   flush_(contentType) {
  1833.     // Never use flush_ if there's data.  It causes a hiccup in playback.
  1834.     goog.asserts.assert(
  1835.         this.video_.buffered.length == 0, 'MediaSourceEngine.flush_ should ' +
  1836.         'only be used after clearing all data!');
  1838.     // Seeking forces the pipeline to be flushed.
  1839.     this.video_.currentTime -= 0.001;
  1841.     // Fake an 'updateend' event to resolve the operation.
  1842.     this.onUpdateEnd_(contentType);
  1843.   }
  1845.   /**
  1846.    * Set the SourceBuffer's timestamp offset.
  1847.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1848.    * @param {number} timestampOffset
  1849.    * @private
  1850.    */
  1851.   setTimestampOffset_(contentType, timestampOffset) {
  1852.     // Work around for
  1853.     // https://github.com/shaka-project/shaka-player/issues/1281:
  1854.     // TODO(https://bit.ly/2ttKiBU): follow up when this is fixed in Edge
  1855.     if (timestampOffset < 0) {
  1856.       // Try to prevent rounding errors in Edge from removing the first
  1857.       // keyframe.
  1858.       timestampOffset += 0.001;
  1859.     }
  1862.     let shouldChangeTimestampOffset = true;
  1863.     if (this.manifestType_ == shaka.media.ManifestParser.HLS) {
  1864.       // Avoid changing timestampOffset when the difference is less than 150 ms
  1865.       // from the end of the current buffer when using sequenceMode
  1866.       const bufferEnd = this.bufferEnd(contentType);
  1867.       if (!bufferEnd || Math.abs(bufferEnd - timestampOffset) > 0.15) {
  1868.         shouldChangeTimestampOffset = true;
  1869.       } else {
  1870.         shouldChangeTimestampOffset = false;
  1871.       }
  1872.     }
  1873.     if (shouldChangeTimestampOffset) {
  1874.       this.sourceBuffers_.get(contentType).timestampOffset = timestampOffset;
  1875.     }
  1877.     // Fake an 'updateend' event to resolve the operation.
  1878.     this.onUpdateEnd_(contentType);
  1879.   }
  1881.   /**
  1882.    * Set the SourceBuffer's append window end.
  1883.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1884.    * @param {number} appendWindowStart
  1885.    * @param {number} appendWindowEnd
  1886.    * @private
  1887.    */
  1888.   setAppendWindow_(contentType, appendWindowStart, appendWindowEnd) {
  1889.     const sourceBuffer = this.sourceBuffers_.get(contentType);
  1890.     // You can't set start > end, so first set start to 0, then set the new
  1891.     // end, then set the new start.  That way, there are no intermediate
  1892.     // states which are invalid.
  1893.     sourceBuffer.appendWindowStart = 0;
  1894.     sourceBuffer.appendWindowEnd = appendWindowEnd;
  1895.     sourceBuffer.appendWindowStart = appendWindowStart;
  1897.     // Fake an 'updateend' event to resolve the operation.
  1898.     this.onUpdateEnd_(contentType);
  1899.   }
  1901.   /**
  1902.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1903.    * @private
  1904.    */
  1905.   onError_(contentType) {
  1906.     const operation = this.queues_.get(contentType)[0];
  1907.     goog.asserts.assert(operation, 'Spurious error event!');
  1908.     goog.asserts.assert(!this.sourceBuffers_.get(contentType).updating,
  1909.         'SourceBuffer should not be updating on error!');
  1910.     const code = this.video_.error ? this.video_.error.code : 0;
  1911.     operation.p.reject(new shaka.util.Error(
  1912.         shaka.util.Error.Severity.CRITICAL,
  1913.         shaka.util.Error.Category.MEDIA,
  1914.         shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_FAILED,
  1915.         code, operation.uri));
  1916.     // Do not pop from queue.  An 'updateend' event will fire next, and to
  1917.     // avoid synchronizing these two event handlers, we will allow that one to
  1918.     // pop from the queue as normal.  Note that because the operation has
  1919.     // already been rejected, the call to resolve() in the 'updateend' handler
  1920.     // will have no effect.
  1921.   }
  1923.   /**
  1924.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1925.    * @private
  1926.    */
  1927.   onUpdateEnd_(contentType) {
  1928.     if (this.reloadingMediaSource_) {
  1929.       return;
  1930.     }
  1931.     const operation = this.queues_.get(contentType)[0];
  1932.     goog.asserts.assert(operation, 'Spurious updateend event!');
  1933.     if (!operation) {
  1934.       return;
  1935.     }
  1936.     goog.asserts.assert(!this.sourceBuffers_.get(contentType).updating,
  1937.         'SourceBuffer should not be updating on updateend!');
  1938.     operation.p.resolve();
  1939.     this.popFromQueue_(contentType);
  1940.   }
  1942.   /**
  1943.    * Enqueue an operation and start it if appropriate.
  1944.    *
  1945.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1946.    * @param {function()} start
  1947.    * @param {?string} uri
  1948.    * @return {!Promise}
  1949.    * @private
  1950.    */
  1951.   enqueueOperation_(contentType, start, uri) {
  1952.     this.destroyer_.ensureNotDestroyed();
  1953.     const operation = {
  1954.       start: start,
  1955.       p: new shaka.util.PublicPromise(),
  1956.       uri,
  1957.     };
  1958.     this.queues_.get(contentType).push(operation);
  1960.     if (this.queues_.get(contentType).length == 1) {
  1961.       this.startOperation_(contentType);
  1962.     }
  1963.     return operation.p;
  1964.   }
  1966.   /**
  1967.    * Enqueue an operation which must block all other operations on all
  1968.    * SourceBuffers.
  1969.    *
  1970.    * @param {function():(Promise|undefined)} run
  1971.    * @return {!Promise}
  1972.    * @private
  1973.    */
  1974.   async enqueueBlockingOperation_(run) {
  1975.     this.destroyer_.ensureNotDestroyed();
  1977.     /** @type {!Array<!shaka.util.PublicPromise>} */
  1978.     const allWaiters = [];
  1979.     /** @type {!Array<!shaka.util.ManifestParserUtils.ContentType>} */
  1980.     const contentTypes = Array.from(this.sourceBuffers_.keys());
  1982.     // Enqueue a 'wait' operation onto each queue.
  1983.     // This operation signals its readiness when it starts.
  1984.     // When all wait operations are ready, the real operation takes place.
  1985.     for (const contentType of contentTypes) {
  1986.       const ready = new shaka.util.PublicPromise();
  1987.       const operation = {
  1988.         start: () => ready.resolve(),
  1989.         p: ready,
  1990.         uri: null,
  1991.       };
  1993.       const queue = this.queues_.get(contentType);
  1995.       queue.push(operation);
  1996.       allWaiters.push(ready);
  1998.       if (queue.length == 1) {
  1999.         operation.start();
  2000.       }
  2001.     }
  2003.     // Return a Promise to the real operation, which waits to begin until
  2004.     // there are no other in-progress operations on any SourceBuffers.
  2005.     try {
  2006.       await Promise.all(allWaiters);
  2007.     } catch (error) {
  2008.       // One of the waiters failed, which means we've been destroyed.
  2009.       goog.asserts.assert(
  2010.           this.destroyer_.destroyed(), 'Should be destroyed by now');
  2011.       // We haven't popped from the queue.  Canceled waiters have been removed
  2012.       // by destroy.  What's left now should just be resolved waiters.  In
  2013.       // uncompiled mode, we will maintain good hygiene and make sure the
  2014.       // assert at the end of destroy passes.  In compiled mode, the queues
  2015.       // are wiped in destroy.
  2016.       if (goog.DEBUG) {
  2017.         for (const contentType of contentTypes) {
  2018.           const queue = this.queues_.get(contentType);
  2019.           if (queue.length) {
  2020.             goog.asserts.assert(queue.length == 1,
  2021.                 'Should be at most one item in queue!');
  2022.             goog.asserts.assert(allWaiters.includes(queue[0].p),
  2023.                 'The item in queue should be one of our waiters!');
  2024.             queue.shift();
  2025.           }
  2026.         }
  2027.       }
  2028.       throw error;
  2029.     }
  2031.     if (goog.DEBUG) {
  2032.       // If we did it correctly, nothing is updating.
  2033.       for (const contentType of contentTypes) {
  2034.         goog.asserts.assert(
  2035.             this.sourceBuffers_.get(contentType).updating == false,
  2036.             'SourceBuffers should not be updating after a blocking op!');
  2037.       }
  2038.     }
  2040.     // Run the real operation, which can be asynchronous.
  2041.     try {
  2042.       await run();
  2043.     } catch (exception) {
  2044.       throw new shaka.util.Error(
  2045.           shaka.util.Error.Severity.CRITICAL,
  2046.           shaka.util.Error.Category.MEDIA,
  2047.           shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  2048.           exception,
  2049.           this.video_.error || 'No error in the media element',
  2050.           null);
  2051.     } finally {
  2052.       // Unblock the queues.
  2053.       for (const contentType of contentTypes) {
  2054.         this.popFromQueue_(contentType);
  2055.       }
  2056.     }
  2057.   }
  2059.   /**
  2060.    * Pop from the front of the queue and start a new operation.
  2061.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2062.    * @private
  2063.    */
  2064.   popFromQueue_(contentType) {
  2065.     goog.asserts.assert(this.queues_.has(contentType), 'Queue should exist');
  2066.     // Remove the in-progress operation, which is now complete.
  2067.     this.queues_.get(contentType).shift();
  2068.     this.startOperation_(contentType);
  2069.   }
  2071.   /**
  2072.    * Starts the next operation in the queue.
  2073.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2074.    * @private
  2075.    */
  2076.   startOperation_(contentType) {
  2077.     // Retrieve the next operation, if any, from the queue and start it.
  2078.     const next = this.queues_.get(contentType)[0];
  2079.     if (next) {
  2080.       try {
  2081.         next.start();
  2082.       } catch (exception) {
  2083.         if (exception.name == 'QuotaExceededError') {
  2084.           next.p.reject(new shaka.util.Error(
  2085.               shaka.util.Error.Severity.CRITICAL,
  2086.               shaka.util.Error.Category.MEDIA,
  2087.               shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR,
  2088.               contentType));
  2089.         } else if (!this.isStreamingAllowed()) {
  2090.           next.p.reject(new shaka.util.Error(
  2091.               shaka.util.Error.Severity.CRITICAL,
  2092.               shaka.util.Error.Category.MEDIA,
  2093.               shaka.util.Error.Code.STREAMING_NOT_ALLOWED,
  2094.               contentType));
  2095.         } else {
  2096.           next.p.reject(new shaka.util.Error(
  2097.               shaka.util.Error.Severity.CRITICAL,
  2098.               shaka.util.Error.Category.MEDIA,
  2099.               shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  2100.               exception,
  2101.               this.video_.error || 'No error in the media element',
  2102.               next.uri));
  2103.         }
  2104.         this.popFromQueue_(contentType);
  2105.       }
  2106.     }
  2107.   }
  2109.   /**
  2110.    * @return {!shaka.extern.TextDisplayer}
  2111.    */
  2112.   getTextDisplayer() {
  2113.     goog.asserts.assert(
  2114.         this.textDisplayer_,
  2115.         'TextDisplayer should only be null when this is destroyed');
  2117.     return this.textDisplayer_;
  2118.   }
  2120.   /**
  2121.    * @param {!shaka.extern.TextDisplayer} textDisplayer
  2122.    */
  2123.   setTextDisplayer(textDisplayer) {
  2124.     this.textDisplayer_ = textDisplayer;
  2125.     if (this.textEngine_) {
  2126.       this.textEngine_.setDisplayer(textDisplayer);
  2127.     }
  2128.   }
  2130.   /**
  2131.    * @param {boolean} segmentRelativeVttTiming
  2132.    */
  2133.   setSegmentRelativeVttTiming(segmentRelativeVttTiming) {
  2134.     this.segmentRelativeVttTiming_ = segmentRelativeVttTiming;
  2135.   }
  2137.   /**
  2138.    * Apply platform-specific transformations to this segment to work around
  2139.    * issues in the platform.
  2140.    *
  2141.    * @param {shaka.extern.Stream} stream
  2142.    * @param {!BufferSource} segment
  2143.    * @param {?shaka.media.SegmentReference} reference
  2144.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2145.    * @return {!BufferSource}
  2146.    * @private
  2147.    */
  2148.   workAroundBrokenPlatforms_(stream, segment, reference, contentType) {
  2149.     const Platform = shaka.util.Platform;
  2151.     const isMp4 = shaka.util.MimeUtils.getContainerType(
  2152.         this.sourceBufferTypes_.get(contentType)) == 'mp4';
  2153.     if (!isMp4) {
  2154.       return segment;
  2155.     }
  2157.     const isInitSegment = reference === null;
  2158.     const encryptionExpected = this.expectedEncryption_.get(contentType);
  2159.     const keySystem = this.playerInterface_.getKeySystem();
  2160.     let isEncrypted = false;
  2161.     if (reference && reference.initSegmentReference) {
  2162.       isEncrypted = reference.initSegmentReference.encrypted;
  2163.     }
  2164.     const uri = reference ? reference.getUris()[0] : null;
  2166.     // If:
  2167.     //   1. the configuration tells to insert fake encryption,
  2168.     //   2. and this is an init segment or media segment,
  2169.     //   3. and encryption is expected,
  2170.     //   4. and the platform requires encryption in all init or media segments
  2171.     //      of current content type,
  2172.     // then insert fake encryption metadata for init segments that lack it.
  2173.     // The MP4 requirement is because we can currently only do this
  2174.     // transformation on MP4 containers.
  2175.     // See: https://github.com/shaka-project/shaka-player/issues/2759
  2176.     if (this.config_.insertFakeEncryptionInInit && encryptionExpected &&
  2177.         Platform.requiresEncryptionInfoInAllInitSegments(keySystem,
  2178.             contentType)) {
  2179.       if (isInitSegment) {
  2180.         shaka.log.debug('Forcing fake encryption information in init segment.');
  2181.         segment =
  2182.             shaka.media.ContentWorkarounds.fakeEncryption(stream, segment, uri);
  2183.       } else if (!isEncrypted && Platform.requiresTfhdFix(contentType)) {
  2184.         shaka.log.debug(
  2185.             'Forcing fake encryption information in media segment.');
  2186.         segment = shaka.media.ContentWorkarounds.fakeMediaEncryption(segment);
  2187.       }
  2188.     }
  2190.     if (isInitSegment && Platform.requiresEC3InitSegments()) {
  2191.       shaka.log.debug('Forcing fake EC-3 information in init segment.');
  2192.       segment = shaka.media.ContentWorkarounds.fakeEC3(segment);
  2193.     }
  2195.     return segment;
  2196.   }
  2198.   /**
  2199.    * Prepare the SourceBuffer to parse a potentially new type or codec.
  2200.    *
  2201.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2202.    * @param {string} mimeType
  2203.    * @param {?shaka.extern.Transmuxer} transmuxer
  2204.    * @private
  2205.    */
  2206.   change_(contentType, mimeType, transmuxer) {
  2207.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2208.     if (contentType === ContentType.TEXT) {
  2209.       shaka.log.debug(`Change not supported for ${contentType}`);
  2210.       return;
  2211.     }
  2212.     const sourceBuffer = this.sourceBufferTypes_.get(contentType);
  2213.     shaka.log.debug(
  2214.         `Change Type: ${sourceBuffer} -> ${mimeType}`);
  2215.     if (shaka.media.Capabilities.isChangeTypeSupported()) {
  2216.       if (this.transmuxers_.has(contentType)) {
  2217.         this.transmuxers_.get(contentType).destroy();
  2218.         this.transmuxers_.delete(contentType);
  2219.       }
  2220.       if (transmuxer) {
  2221.         this.transmuxers_.set(contentType, transmuxer);
  2222.       }
  2223.       const type = this.addExtraFeaturesToMimeType_(mimeType);
  2224.       this.sourceBuffers_.get(contentType).changeType(type);
  2225.       this.sourceBufferTypes_.set(contentType, mimeType);
  2226.     } else {
  2227.       shaka.log.debug('Change Type not supported');
  2228.     }
  2230.     // Fake an 'updateend' event to resolve the operation.
  2231.     this.onUpdateEnd_(contentType);
  2232.   }
  2234.   /**
  2235.    * Enqueue an operation to prepare the SourceBuffer to parse a potentially new
  2236.    * type or codec.
  2237.    *
  2238.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2239.    * @param {string} mimeType
  2240.    * @param {?shaka.extern.Transmuxer} transmuxer
  2241.    * @return {!Promise}
  2242.    */
  2243.   changeType(contentType, mimeType, transmuxer) {
  2244.     return this.enqueueOperation_(
  2245.         contentType,
  2246.         () => this.change_(contentType, mimeType, transmuxer),
  2247.         null);
  2248.   }
  2250.   /**
  2251.    * Resets the MediaSource and re-adds source buffers due to codec mismatch
  2252.    *
  2253.    * @param {!Map<shaka.util.ManifestParserUtils.ContentType,
  2254.    *               shaka.extern.Stream>} streamsByType
  2255.    * @private
  2256.    */
  2257.   async reset_(streamsByType) {
  2258.     if (this.reloadingMediaSource_) {
  2259.       return;
  2260.     }
  2261.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2262.     this.reloadingMediaSource_ = true;
  2263.     this.needSplitMuxedContent_ = false;
  2264.     const currentTime = this.video_.currentTime;
  2266.     // When codec switching if the user is currently paused we don't want
  2267.     // to trigger a play when switching codec.
  2268.     // Playing can also end up in a paused state after a codec switch
  2269.     // so we need to remember the current states.
  2270.     const previousAutoPlayState = this.video_.autoplay;
  2271.     if (!this.video_.paused) {
  2272.       this.playAfterReset_ = true;
  2273.     }
  2274.     if (this.playbackHasBegun_) {
  2275.       // Only set autoplay to false if the video playback has already begun.
  2276.       // When a codec switch happens before playback has begun this can cause
  2277.       // autoplay not to work as expected.
  2278.       this.video_.autoplay = false;
  2279.     }
  2281.     try {
  2282.       this.eventManager_.removeAll();
  2284.       for (const transmuxer of this.transmuxers_.values()) {
  2285.         transmuxer.destroy();
  2286.       }
  2287.       for (const sourceBuffer of this.sourceBuffers_.values()) {
  2288.         try {
  2289.           this.mediaSource_.removeSourceBuffer(sourceBuffer);
  2290.         } catch (e) {
  2291.           shaka.log.debug('Exception on removeSourceBuffer', e);
  2292.         }
  2293.       }
  2294.       this.transmuxers_.clear();
  2295.       this.sourceBuffers_.clear();
  2297.       const previousDuration = this.mediaSource_.duration;
  2298.       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
  2299.       this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
  2300.       await this.mediaSourceOpen_;
  2301.       if (!isNaN(previousDuration) && previousDuration) {
  2302.         this.mediaSource_.duration = previousDuration;
  2303.       } else if (!isNaN(this.lastDuration_) && this.lastDuration_) {
  2304.         this.mediaSource_.duration = this.lastDuration_;
  2305.       }
  2307.       const sourceBufferAdded = new shaka.util.PublicPromise();
  2308.       const sourceBuffers =
  2309.         /** @type {EventTarget} */(this.mediaSource_.sourceBuffers);
  2311.       const totalOfBuffers = streamsByType.size;
  2312.       let numberOfSourceBufferAdded = 0;
  2313.       const onSourceBufferAdded = () => {
  2314.         numberOfSourceBufferAdded++;
  2315.         if (numberOfSourceBufferAdded === totalOfBuffers) {
  2316.           sourceBufferAdded.resolve();
  2317.           this.eventManager_.unlisten(sourceBuffers, 'addsourcebuffer',
  2318.               onSourceBufferAdded);
  2319.         }
  2320.       };
  2322.       this.eventManager_.listen(sourceBuffers, 'addsourcebuffer',
  2323.           onSourceBufferAdded);
  2325.       for (const contentType of streamsByType.keys()) {
  2326.         const stream = streamsByType.get(contentType);
  2327.         // eslint-disable-next-line no-await-in-loop
  2328.         await this.initSourceBuffer_(contentType, stream, stream.codecs);
  2329.       }
  2330.       const audio = streamsByType.get(ContentType.AUDIO);
  2331.       if (audio && audio.isAudioMuxedInVideo) {
  2332.         this.needSplitMuxedContent_ = true;
  2333.       }
  2334.       if (this.needSplitMuxedContent_ && !this.queues_.has(ContentType.AUDIO)) {
  2335.         this.queues_.set(ContentType.AUDIO, []);
  2336.       }
  2338.       // Fake a seek to catchup the playhead.
  2339.       this.video_.currentTime = currentTime;
  2341.       await sourceBufferAdded;
  2342.     } finally {
  2343.       this.reloadingMediaSource_ = false;
  2345.       this.destroyer_.ensureNotDestroyed();
  2347.       this.eventManager_.listenOnce(this.video_, 'canplaythrough', () => {
  2348.         // Don't use ensureNotDestroyed() from this event listener, because
  2349.         // that results in an uncaught exception.  Instead, just check the
  2350.         // flag.
  2351.         if (this.destroyer_.destroyed()) {
  2352.           return;
  2353.         }
  2355.         this.video_.autoplay = previousAutoPlayState;
  2356.         if (this.playAfterReset_) {
  2357.           this.playAfterReset_ = false;
  2358.           this.video_.play();
  2359.         }
  2360.       });
  2361.     }
  2362.   }
  2364.   /**
  2365.    * Resets the Media Source
  2366.    * @param {!Map<shaka.util.ManifestParserUtils.ContentType,
  2367.    *               shaka.extern.Stream>} streamsByType
  2368.    * @return {!Promise}
  2369.    */
  2370.   reset(streamsByType) {
  2371.     return this.enqueueBlockingOperation_(
  2372.         () => this.reset_(streamsByType));
  2373.   }
  2375.   /**
  2376.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2377.    * @param {string} mimeType
  2378.    * @param {string} codecs
  2379.    * @return {{transmuxer: ?shaka.extern.Transmuxer,
  2380.    *          transmuxerMuxed: boolean, basicType: string, codec: string,
  2381.    *          mimeType: string}}
  2382.    * @private
  2383.    */
  2384.   getRealInfo_(contentType, mimeType, codecs) {
  2385.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2386.     const MimeUtils = shaka.util.MimeUtils;
  2387.     /** @type {?shaka.extern.Transmuxer} */
  2388.     let transmuxer;
  2389.     let transmuxerMuxed = false;
  2390.     const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  2391.         ContentType.AUDIO, (codecs || '').split(','));
  2392.     const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  2393.         ContentType.VIDEO, (codecs || '').split(','));
  2394.     let codec = videoCodec;
  2395.     if (contentType == ContentType.AUDIO) {
  2396.       codec = audioCodec;
  2397.     }
  2398.     if (!codec) {
  2399.       codec = codecs;
  2400.     }
  2401.     let newMimeType = shaka.util.MimeUtils.getFullType(mimeType, codec);
  2402.     let needTransmux = this.config_.forceTransmux;
  2403.     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
  2404.         (!this.sequenceMode_ &&
  2405.         shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
  2406.       needTransmux = true;
  2407.     }
  2408.     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
  2409.     if (needTransmux) {
  2410.       const newMimeTypeWithAllCodecs =
  2411.           shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codec);
  2412.       const transmuxerPlugin =
  2413.           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
  2414.       if (transmuxerPlugin) {
  2415.         transmuxer = transmuxerPlugin();
  2416.         if (audioCodec && videoCodec) {
  2417.           transmuxerMuxed = true;
  2418.         }
  2419.         newMimeType =
  2420.             transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
  2421.       }
  2422.     }
  2424.     const newCodec = MimeUtils.getNormalizedCodec(
  2425.         MimeUtils.getCodecs(newMimeType));
  2426.     const newBasicType = MimeUtils.getBasicType(newMimeType);
  2427.     return {
  2428.       transmuxer,
  2429.       transmuxerMuxed,
  2430.       basicType: newBasicType,
  2431.       codec: newCodec,
  2432.       mimeType: newMimeType,
  2433.     };
  2434.   }
  2436.   /**
  2437.    * Codec switch if necessary, this will not resolve until the codec
  2438.    * switch is over.
  2439.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2440.    * @param {string} mimeType
  2441.    * @param {string} codecs
  2442.    * @param {!Map<shaka.util.ManifestParserUtils.ContentType,
  2443.    *               shaka.extern.Stream>} streamsByType
  2444.    * @return {!Promise<boolean>} true if there was a codec switch,
  2445.    *                              false otherwise.
  2446.    * @private
  2447.    */
  2448.   async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
  2449.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2450.     if (contentType == ContentType.TEXT) {
  2451.       return false;
  2452.     }
  2453.     const MimeUtils = shaka.util.MimeUtils;
  2454.     const currentCodec = MimeUtils.getNormalizedCodec(
  2455.         MimeUtils.getCodecs(this.sourceBufferTypes_.get(contentType)));
  2456.     const currentBasicType = MimeUtils.getBasicType(
  2457.         this.sourceBufferTypes_.get(contentType));
  2459.     const realInfo = this.getRealInfo_(contentType, mimeType, codecs);
  2460.     const transmuxer = realInfo.transmuxer;
  2461.     const transmuxerMuxed = realInfo.transmuxerMuxed;
  2462.     const newBasicType = realInfo.basicType;
  2463.     const newCodec = realInfo.codec;
  2464.     const newMimeType = realInfo.mimeType;
  2466.     let muxedContentCheck = true;
  2467.     if (transmuxerMuxed &&
  2468.         this.sourceBufferTypes_.has(ContentType.AUDIO)) {
  2469.       const muxedRealInfo =
  2470.           this.getRealInfo_(ContentType.AUDIO, mimeType, codecs);
  2471.       const muxedCurrentCodec = MimeUtils.getNormalizedCodec(
  2472.           MimeUtils.getCodecs(this.sourceBufferTypes_.get(ContentType.AUDIO)));
  2473.       const muxedCurrentBasicType = MimeUtils.getBasicType(
  2474.           this.sourceBufferTypes_.get(ContentType.AUDIO));
  2475.       muxedContentCheck = muxedCurrentCodec == muxedRealInfo.codec &&
  2476.         muxedCurrentBasicType == muxedRealInfo.basicType;
  2477.       if (muxedRealInfo.transmuxer) {
  2478.         muxedRealInfo.transmuxer.destroy();
  2479.       }
  2480.     }
  2482.     // Current/new codecs base and basic type match then no need to switch
  2483.     if (currentCodec === newCodec && currentBasicType === newBasicType &&
  2484.         muxedContentCheck) {
  2485.       if (this.transmuxers_.has(contentType) && !transmuxer) {
  2486.         this.transmuxers_.get(contentType).destroy();
  2487.         this.transmuxers_.delete(contentType);
  2488.       } else if (!this.transmuxers_.has(contentType) && transmuxer) {
  2489.         this.transmuxers_.set(contentType, transmuxer);
  2490.       } else if (transmuxer) {
  2491.         // Compare if the transmuxer is different
  2492.         if (this.transmuxers_.has(contentType) &&
  2493.             this.transmuxers_.get(contentType).transmux !=
  2494.               transmuxer.transmux) {
  2495.           this.transmuxers_.get(contentType).destroy();
  2496.           this.transmuxers_.delete(contentType);
  2497.           this.transmuxers_.set(contentType, transmuxer);
  2498.         } else {
  2499.           transmuxer.destroy();
  2500.         }
  2501.       }
  2502.       return false;
  2503.     }
  2505.     let allowChangeType = true;
  2506.     if (this.needSplitMuxedContent_ || (transmuxerMuxed &&
  2507.         transmuxer && !this.transmuxers_.has(contentType))) {
  2508.       allowChangeType = false;
  2509.     }
  2511.     if (allowChangeType && this.config_.codecSwitchingStrategy ===
  2512.         shaka.config.CodecSwitchingStrategy.SMOOTH &&
  2513.           shaka.media.Capabilities.isChangeTypeSupported()) {
  2514.       await this.changeType(contentType, newMimeType, transmuxer);
  2515.     } else {
  2516.       if (transmuxer) {
  2517.         transmuxer.destroy();
  2518.       }
  2519.       await this.reset(streamsByType);
  2520.     }
  2521.     return true;
  2522.   }
  2524.   /**
  2525.    * Returns true if it's necessary codec switch to load the new stream.
  2526.    *
  2527.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2528.    * @param {string} refMimeType
  2529.    * @param {string} refCodecs
  2530.    * @return {boolean}
  2531.    * @private
  2532.    */
  2533.   isCodecSwitchNecessary_(contentType, refMimeType, refCodecs) {
  2534.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  2535.       return false;
  2536.     }
  2537.     const MimeUtils = shaka.util.MimeUtils;
  2538.     const currentCodec = MimeUtils.getNormalizedCodec(
  2539.         MimeUtils.getCodecs(this.sourceBufferTypes_.get(contentType)));
  2540.     const currentBasicType = MimeUtils.getBasicType(
  2541.         this.sourceBufferTypes_.get(contentType));
  2543.     let newMimeType = shaka.util.MimeUtils.getFullType(refMimeType, refCodecs);
  2544.     let needTransmux = this.config_.forceTransmux;
  2545.     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
  2546.         (!this.sequenceMode_ &&
  2547.         shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
  2548.       needTransmux = true;
  2549.     }
  2550.     const newMimeTypeWithAllCodecs =
  2551.         shaka.util.MimeUtils.getFullTypeWithAllCodecs(
  2552.             refMimeType, refCodecs);
  2553.     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
  2554.     if (needTransmux) {
  2555.       const transmuxerPlugin =
  2556.           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
  2557.       if (transmuxerPlugin) {
  2558.         const transmuxer = transmuxerPlugin();
  2559.         newMimeType =
  2560.             transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
  2561.         transmuxer.destroy();
  2562.       }
  2563.     }
  2565.     const newCodec = MimeUtils.getNormalizedCodec(
  2566.         MimeUtils.getCodecs(newMimeType));
  2567.     const newBasicType = MimeUtils.getBasicType(newMimeType);
  2569.     return currentCodec !== newCodec || currentBasicType !== newBasicType;
  2570.   }
  2572.   /**
  2573.    * Returns true if it's necessary reset the media source to load the
  2574.    * new stream.
  2575.    *
  2576.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2577.    * @param {string} mimeType
  2578.    * @param {string} codecs
  2579.    * @return {boolean}
  2580.    */
  2581.   isResetMediaSourceNecessary(contentType, mimeType, codecs) {
  2582.     if (!this.isCodecSwitchNecessary_(contentType, mimeType, codecs)) {
  2583.       return false;
  2584.     }
  2586.     return this.config_.codecSwitchingStrategy !==
  2587.         shaka.config.CodecSwitchingStrategy.SMOOTH ||
  2588.         !shaka.media.Capabilities.isChangeTypeSupported() ||
  2589.         this.needSplitMuxedContent_;
  2590.   }
  2592.   /**
  2593.    * Update LCEVC Decoder object when ready for LCEVC Decode.
  2594.    * @param {?shaka.lcevc.Dec} lcevcDec
  2595.    */
  2596.   updateLcevcDec(lcevcDec) {
  2597.     this.lcevcDec_ = lcevcDec;
  2598.   }
  2600.   /**
  2601.    * @param {string} mimeType
  2602.    * @return {string}
  2603.    * @private
  2604.    */
  2605.   addExtraFeaturesToMimeType_(mimeType) {
  2606.     const extraFeatures = this.config_.addExtraFeaturesToSourceBuffer(mimeType);
  2607.     const extendedType = mimeType + extraFeatures;
  2608.     shaka.log.debug('Using full mime type', extendedType);
  2610.     return extendedType;
  2611.   }
  2612. };
  2615. /**
  2616.  * Internal reference to window.URL.createObjectURL function to avoid
  2617.  * compatibility issues with other libraries and frameworks such as React
  2618.  * Native. For use in unit tests only, not meant for external use.
  2619.  *
  2620.  * @type {function(?):string}
  2621.  */
  2622. shaka.media.MediaSourceEngine.createObjectURL = window.URL.createObjectURL;
  2625. /**
  2626.  * @typedef {{
  2627.  *   start: function(),
  2628.  *   p: !shaka.util.PublicPromise,
  2629.  *   uri: ?string
  2630.  * }}
  2631.  *
  2632.  * @summary An operation in queue.
  2633.  * @property {function()} start
  2634.  *   The function which starts the operation.
  2635.  * @property {!shaka.util.PublicPromise} p
  2636.  *   The PublicPromise which is associated with this operation.
  2637.  * @property {?string} uri
  2638.  *   A segment URI (if any) associated with this operation.
  2639.  */
  2640. shaka.media.MediaSourceEngine.Operation;
  2643. /**
  2644.  * @enum {string}
  2645.  * @private
  2646.  */
  2647. shaka.media.MediaSourceEngine.SourceBufferMode_ = {
  2648.   SEQUENCE: 'sequence',
  2649.   SEGMENTS: 'segments',
  2650. };
  2653. /**
  2654.  * @typedef {{
  2655.  *   getKeySystem: function():?string,
  2656.  *   onMetadata: function(!Array<shaka.extern.ID3Metadata>, number, ?number),
  2657.  *   onEmsg: function(!shaka.extern.EmsgInfo),
  2658.  *   onEvent: function(!Event),
  2659.  *   onManifestUpdate: function()
  2660.  * }}
  2661.  *
  2662.  * @summary Player interface
  2663.  * @property {function():?string} getKeySystem
  2664.  *   Gets currently used key system or null if not used.
  2665.  * @property {function(
  2666.  *     !Array<shaka.extern.ID3Metadata>, number, ?number)} onMetadata
  2667.  *   Callback to use when metadata arrives.
  2668.  * @property {function(!shaka.extern.EmsgInfo)} onEmsg
  2669.  *   Callback to use when EMSG arrives.
  2670.  * @property {function(!Event)} onEvent
  2671.  *   Called when an event occurs that should be sent to the app.
  2672.  * @property {function()} onManifestUpdate
  2673.  *   Called when an embedded 'emsg' box should trigger a manifest update.
  2674.  */
  2675. shaka.media.MediaSourceEngine.PlayerInterface;