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.Error');
  24. goog.require('shaka.util.EventManager');
  25. goog.require('shaka.util.Functional');
  26. goog.require('shaka.util.IDestroyable');
  27. goog.require('shaka.util.Id3Utils');
  28. goog.require('shaka.util.ManifestParserUtils');
  29. goog.require('shaka.util.MimeUtils');
  30. goog.require('shaka.util.Mp4BoxParsers');
  31. goog.require('shaka.util.Mp4Parser');
  32. goog.require('shaka.util.Platform');
  33. goog.require('shaka.util.PublicPromise');
  34. goog.require('shaka.util.StreamUtils');
  35. goog.require('shaka.util.TsParser');
  36. goog.require('shaka.lcevc.Dec');
  39. /**
  40.  * @summary
  41.  * MediaSourceEngine wraps all operations on MediaSource and SourceBuffers.
  42.  * All asynchronous operations return a Promise, and all operations are
  43.  * internally synchronized and serialized as needed.  Operations that can
  44.  * be done in parallel will be done in parallel.
  45.  *
  46.  * @implements {shaka.util.IDestroyable}
  47.  */
  48. shaka.media.MediaSourceEngine = class {
  49.   /**
  50.    * @param {HTMLMediaElement} video The video element, whose source is tied to
  51.    *   MediaSource during the lifetime of the MediaSourceEngine.
  52.    * @param {!shaka.extern.TextDisplayer} textDisplayer
  53.    *    The text displayer that will be used with the text engine.
  54.    *    MediaSourceEngine takes ownership of the displayer. When
  55.    *    MediaSourceEngine is destroyed, it will destroy the displayer.
  56.    * @param {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)=}
  57.    *    onMetadata
  58.    * @param {?shaka.lcevc.Dec} [lcevcDec] Optional -  LCEVC Decoder Object
  59.    *
  60.    */
  61.   constructor(video, textDisplayer, onMetadata, lcevcDec) {
  62.     /** @private {HTMLMediaElement} */
  63.     this.video_ = video;
  65.     /** @private {?shaka.extern.MediaSourceConfiguration} */
  66.     this.config_ = null;
  68.     /** @private {shaka.extern.TextDisplayer} */
  69.     this.textDisplayer_ = textDisplayer;
  71.     /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  72.                            SourceBuffer>} */
  73.     this.sourceBuffers_ = {};
  75.     /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  76.                            string>} */
  77.     this.sourceBufferTypes_ = {};
  80.     /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  81.                            boolean>} */
  82.     this.expectedEncryption_ = {};
  84.     /** @private {shaka.text.TextEngine} */
  85.     this.textEngine_ = null;
  87.     /** @private {boolean} */
  88.     this.segmentRelativeVttTiming_ = false;
  90.     const onMetadataNoOp = (metadata, timestampOffset, segmentEnd) => {};
  92.     /** @private {!function(!Array.<shaka.extern.ID3Metadata>,
  93.                     number, ?number)} */
  94.     this.onMetadata_ = onMetadata || onMetadataNoOp;
  96.     /** @private {?shaka.lcevc.Dec} */
  97.     this.lcevcDec_ = lcevcDec || null;
  99.     /**
  100.      * @private {!Object.<string,
  101.      *                    !Array.<shaka.media.MediaSourceEngine.Operation>>}
  102.      */
  103.     this.queues_ = {};
  105.     /** @private {shaka.util.EventManager} */
  106.     this.eventManager_ = new shaka.util.EventManager();
  108.     /** @private {!Object.<string, !shaka.extern.Transmuxer>} */
  109.     this.transmuxers_ = {};
  111.     /** @private {?shaka.media.IClosedCaptionParser} */
  112.     this.captionParser_ = null;
  114.     /** @private {!shaka.util.PublicPromise} */
  115.     this.mediaSourceOpen_ = new shaka.util.PublicPromise();
  117.     /** @private {string} */
  118.     this.url_ = '';
  120.     /** @private {boolean} */
  121.     this.playbackHasBegun_ = false;
  123.     /** @private {(MediaSource|ManagedMediaSource)} */
  124.     this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
  126.     /** @private {boolean} */
  127.     this.reloadingMediaSource_ = false;
  129.     /** @type {!shaka.util.Destroyer} */
  130.     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
  132.     /** @private {boolean} */
  133.     this.sequenceMode_ = false;
  135.     /** @private {string} */
  136.     this.manifestType_ = shaka.media.ManifestParser.UNKNOWN;
  138.     /** @private {boolean} */
  139.     this.ignoreManifestTimestampsInSegmentsMode_ = false;
  141.     /** @private {boolean} */
  142.     this.attemptTimestampOffsetCalculation_ = false;
  144.     /** @private {!shaka.util.PublicPromise.<number>} */
  145.     this.textSequenceModeOffset_ = new shaka.util.PublicPromise();
  147.     /** @private {boolean} */
  148.     this.needSplitMuxedContent_ = false;
  150.     /** @private {boolean} */
  151.     this.streamingAllowed_ = true;
  153.     /** @private {?number} */
  154.     this.lastDuration_ = null;
  156.     /** @private {?shaka.util.TsParser} */
  157.     this.tsParser_ = null;
  158.   }
  160.   /**
  161.    * Create a MediaSource object, attach it to the video element, and return it.
  162.    * Resolves the given promise when the MediaSource is ready.
  163.    *
  164.    * Replaced by unit tests.
  165.    *
  166.    * @param {!shaka.util.PublicPromise} p
  167.    * @return {!(MediaSource|ManagedMediaSource)}
  168.    */
  169.   createMediaSource(p) {
  170.     if (window.ManagedMediaSource) {
  171.       this.video_.disableRemotePlayback = true;
  173.       const mediaSource = new ManagedMediaSource();
  175.       this.eventManager_.listen(
  176.           mediaSource, 'startstreaming', () => {
  177.             this.streamingAllowed_ = true;
  178.           });
  180.       this.eventManager_.listen(
  181.           mediaSource, 'endstreaming', () => {
  182.             this.streamingAllowed_ = false;
  183.           });
  185.       this.eventManager_.listenOnce(
  186.           mediaSource, 'sourceopen', () => this.onSourceOpen_(p));
  188.       // Correctly set when playback has begun.
  189.       this.eventManager_.listenOnce(this.video_, 'playing', () => {
  190.         this.playbackHasBegun_ = true;
  191.       });
  193.       this.url_ = shaka.media.MediaSourceEngine.createObjectURL(mediaSource);
  195.       this.video_.src = this.url_;
  197.       return mediaSource;
  198.     } else {
  199.       const mediaSource = new MediaSource();
  201.       // Set up MediaSource on the video element.
  202.       this.eventManager_.listenOnce(
  203.           mediaSource, 'sourceopen', () => this.onSourceOpen_(p));
  205.       // Correctly set when playback has begun.
  206.       this.eventManager_.listenOnce(this.video_, 'playing', () => {
  207.         this.playbackHasBegun_ = true;
  208.       });
  210.       // Store the object URL for releasing it later.
  211.       this.url_ = shaka.media.MediaSourceEngine.createObjectURL(mediaSource);
  213.       this.video_.src = this.url_;
  215.       return mediaSource;
  216.     }
  217.   }
  219.   /**
  220.    * @param {shaka.util.PublicPromise} p
  221.    * @private
  222.    */
  223.   onSourceOpen_(p) {
  224.     goog.asserts.assert(this.url_, 'Must have object URL');
  226.     // Release the object URL that was previously created, to prevent memory
  227.     // leak.
  228.     // createObjectURL creates a strong reference to the MediaSource object
  229.     // inside the browser.  Setting the src of the video then creates another
  230.     // reference within the video element.  revokeObjectURL will remove the
  231.     // strong reference to the MediaSource object, and allow it to be
  232.     // garbage-collected later.
  233.     URL.revokeObjectURL(this.url_);
  234.     p.resolve();
  235.   }
  237.   /**
  238.    * Checks if a certain type is supported.
  239.    *
  240.    * @param {shaka.extern.Stream} stream
  241.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  242.    * @return {!Promise.<boolean>}
  243.    */
  244.   static async isStreamSupported(stream, contentType) {
  245.     if (stream.createSegmentIndex) {
  246.       await stream.createSegmentIndex();
  247.     }
  248.     if (!stream.segmentIndex) {
  249.       return false;
  250.     }
  251.     if (stream.segmentIndex.isEmpty()) {
  252.       return true;
  253.     }
  254.     const MimeUtils = shaka.util.MimeUtils;
  255.     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
  256.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  257.     const StreamUtils = shaka.util.StreamUtils;
  258.     const seenCombos = new Set();
  259.     // Check each combination of mimeType and codecs within the segment index.
  260.     // Unfortunately we cannot use fullMimeTypes, as we ALSO need to check the
  261.     // getFullTypeWithAllCodecs (for the sake of the transmuxer) and we have no
  262.     // way of going from a full mimeType to a full mimeType with all codecs.
  263.     // As this function is only called in debug mode, a little inefficiency is
  264.     // acceptable.
  265.     for (const ref of stream.segmentIndex) {
  266.       const mimeType = ref.mimeType || stream.mimeType || '';
  267.       let codecs = ref.codecs || stream.codecs || '';
  268.       // Don't check the same combination of mimetype + codecs twice.
  269.       const combo = mimeType + ':' + codecs;
  270.       if (seenCombos.has(combo)) {
  271.         continue;
  272.       }
  273.       seenCombos.add(combo);
  274.       if (contentType == ContentType.TEXT) {
  275.         const fullMimeType = MimeUtils.getFullType(mimeType, codecs);
  276.         if (!shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
  277.           return false;
  278.         }
  279.       } else {
  280.         if (contentType == ContentType.VIDEO) {
  281.           codecs = StreamUtils.getCorrectVideoCodecs(codecs);
  282.         } else if (contentType == ContentType.AUDIO) {
  283.           codecs = StreamUtils.getCorrectAudioCodecs(codecs, mimeType);
  284.         }
  285.         const extendedMimeType = MimeUtils.getExtendedType(
  286.             stream, mimeType, codecs);
  287.         const fullMimeType = MimeUtils.getFullTypeWithAllCodecs(
  288.             mimeType, codecs);
  289.         if (!shaka.media.Capabilities.isTypeSupported(extendedMimeType) &&
  290.             !TransmuxerEngine.isSupported(fullMimeType, stream.type)) {
  291.           return false;
  292.         }
  293.       }
  294.     }
  295.     return true;
  296.   }
  298.   /**
  299.    * Returns a map of MediaSource support for well-known types.
  300.    *
  301.    * @return {!Object.<string, boolean>}
  302.    */
  303.   static probeSupport() {
  304.     const testMimeTypes = [
  305.       // MP4 types
  306.       'video/mp4; codecs="avc1.42E01E"',
  307.       'video/mp4; codecs="avc3.42E01E"',
  308.       'video/mp4; codecs="hev1.1.6.L93.90"',
  309.       'video/mp4; codecs="hvc1.1.6.L93.90"',
  310.       'video/mp4; codecs="hev1.2.4.L153.B0"; eotf="smpte2084"',  // HDR HEVC
  311.       'video/mp4; codecs="hvc1.2.4.L153.B0"; eotf="smpte2084"',  // HDR HEVC
  312.       'video/mp4; codecs="vp9"',
  313.       'video/mp4; codecs="vp09.00.10.08"',
  314.       'video/mp4; codecs="av01.0.01M.08"',
  315.       'video/mp4; codecs="dvh1.20.01"',
  316.       'audio/mp4; codecs="mp4a.40.2"',
  317.       'audio/mp4; codecs="ac-3"',
  318.       'audio/mp4; codecs="ec-3"',
  319.       'audio/mp4; codecs="ac-4.02.01.01"',
  320.       'audio/mp4; codecs="opus"',
  321.       'audio/mp4; codecs="flac"',
  322.       'audio/mp4; codecs="dtsc"', // DTS Digital Surround
  323.       'audio/mp4; codecs="dtse"', // DTS Express
  324.       'audio/mp4; codecs="dtsx"', // DTS:X
  325.       // WebM types
  326.       'video/webm; codecs="vp8"',
  327.       'video/webm; codecs="vp9"',
  328.       'video/webm; codecs="vp09.00.10.08"',
  329.       'audio/webm; codecs="vorbis"',
  330.       'audio/webm; codecs="opus"',
  331.       // MPEG2 TS types (video/ is also used for audio: https://bit.ly/TsMse)
  332.       'video/mp2t; codecs="avc1.42E01E"',
  333.       'video/mp2t; codecs="avc3.42E01E"',
  334.       'video/mp2t; codecs="hvc1.1.6.L93.90"',
  335.       'video/mp2t; codecs="mp4a.40.2"',
  336.       'video/mp2t; codecs="ac-3"',
  337.       'video/mp2t; codecs="ec-3"',
  338.       // WebVTT types
  339.       'text/vtt',
  340.       'application/mp4; codecs="wvtt"',
  341.       // TTML types
  342.       'application/ttml+xml',
  343.       'application/mp4; codecs="stpp"',
  344.       // Containerless types
  345.       ...shaka.util.MimeUtils.RAW_FORMATS,
  346.     ];
  348.     const support = {};
  349.     for (const type of testMimeTypes) {
  350.       if (shaka.text.TextEngine.isTypeSupported(type)) {
  351.         support[type] = true;
  352.       } else if (shaka.util.Platform.supportsMediaSource()) {
  353.         support[type] = shaka.media.Capabilities.isTypeSupported(type) ||
  354.                         shaka.transmuxer.TransmuxerEngine.isSupported(type);
  355.       } else {
  356.         support[type] = shaka.util.Platform.supportsMediaType(type);
  357.       }
  359.       const basicType = type.split(';')[0];
  360.       support[basicType] = support[basicType] || support[type];
  361.     }
  363.     return support;
  364.   }
  366.   /** @override */
  367.   destroy() {
  368.     return this.destroyer_.destroy();
  369.   }
  371.   /** @private */
  372.   async doDestroy_() {
  373.     const Functional = shaka.util.Functional;
  375.     const cleanup = [];
  377.     for (const contentType in this.queues_) {
  378.       // Make a local copy of the queue and the first item.
  379.       const q = this.queues_[contentType];
  380.       const inProgress = q[0];
  382.       // Drop everything else out of the original queue.
  383.       this.queues_[contentType] = q.slice(0, 1);
  385.       // We will wait for this item to complete/fail.
  386.       if (inProgress) {
  387.         cleanup.push(inProgress.p.catch(Functional.noop));
  388.       }
  390.       // The rest will be rejected silently if possible.
  391.       for (const item of q.slice(1)) {
  392.         item.p.reject(shaka.util.Destroyer.destroyedError());
  393.       }
  394.     }
  396.     if (this.textEngine_) {
  397.       cleanup.push(this.textEngine_.destroy());
  398.     }
  399.     if (this.textDisplayer_) {
  400.       cleanup.push(this.textDisplayer_.destroy());
  401.     }
  403.     for (const contentType in this.transmuxers_) {
  404.       cleanup.push(this.transmuxers_[contentType].destroy());
  405.     }
  408.     await Promise.all(cleanup);
  409.     if (this.eventManager_) {
  410.       this.eventManager_.release();
  411.       this.eventManager_ = null;
  412.     }
  414.     if (this.video_) {
  415.       // "unload" the video element.
  416.       this.video_.removeAttribute('src');
  417.       this.video_.load();
  418.       this.video_ = null;
  419.     }
  421.     this.config_ = null;
  422.     this.mediaSource_ = null;
  423.     this.textEngine_ = null;
  424.     this.textDisplayer_ = null;
  425.     this.sourceBuffers_ = {};
  426.     this.transmuxers_ = {};
  427.     this.captionParser_ = null;
  428.     if (goog.DEBUG) {
  429.       for (const contentType in this.queues_) {
  430.         goog.asserts.assert(
  431.             this.queues_[contentType].length == 0,
  432.             contentType + ' queue should be empty after destroy!');
  433.       }
  434.     }
  435.     this.queues_ = {};
  437.     // This object is owned by Player
  438.     this.lcevcDec_ = null;
  440.     this.tsParser_ = null;
  441.   }
  443.   /**
  444.    * @return {!Promise} Resolved when MediaSource is open and attached to the
  445.    *   media element.  This process is actually initiated by the constructor.
  446.    */
  447.   open() {
  448.     return this.mediaSourceOpen_;
  449.   }
  451.   /**
  452.    * Initialize MediaSourceEngine.
  453.    *
  454.    * Note that it is not valid to call this multiple times, except to add or
  455.    * reinitialize text streams.
  456.    *
  457.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  458.    *               shaka.extern.Stream>} streamsByType
  459.    *   A map of content types to streams.  All streams must be supported
  460.    *   according to MediaSourceEngine.isStreamSupported.
  461.    * @param {boolean=} sequenceMode
  462.    *   If true, the media segments are appended to the SourceBuffer in strict
  463.    *   sequence.
  464.    * @param {string=} manifestType
  465.    *   Indicates the type of the manifest.
  466.    * @param {boolean=} ignoreManifestTimestampsInSegmentsMode
  467.    *   If true, don't adjust the timestamp offset to account for manifest
  468.    *   segment durations being out of sync with segment durations. In other
  469.    *   words, assume that there are no gaps in the segments when appending
  470.    *   to the SourceBuffer, even if the manifest and segment times disagree.
  471.    *   Indicates if the manifest has text streams.
  472.    *
  473.    * @return {!Promise}
  474.    */
  475.   async init(streamsByType, sequenceMode=false,
  476.       manifestType=shaka.media.ManifestParser.UNKNOWN,
  477.       ignoreManifestTimestampsInSegmentsMode=false) {
  478.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  480.     await this.mediaSourceOpen_;
  482.     this.sequenceMode_ = sequenceMode;
  483.     this.manifestType_ = manifestType;
  484.     this.ignoreManifestTimestampsInSegmentsMode_ =
  485.       ignoreManifestTimestampsInSegmentsMode;
  487.     this.attemptTimestampOffsetCalculation_ = !this.sequenceMode_ &&
  488.         this.manifestType_ == shaka.media.ManifestParser.HLS &&
  489.         !this.ignoreManifestTimestampsInSegmentsMode_;
  491.     this.tsParser_ = null;
  493.     for (const contentType of streamsByType.keys()) {
  494.       const stream = streamsByType.get(contentType);
  495.       // eslint-disable-next-line no-await-in-loop
  496.       await this.initSourceBuffer_(contentType, stream, stream.codecs);
  497.       if (this.needSplitMuxedContent_) {
  498.         this.queues_[ContentType.AUDIO] = [];
  499.         this.queues_[ContentType.VIDEO] = [];
  500.       } else {
  501.         this.queues_[contentType] = [];
  502.       }
  503.     }
  504.   }
  506.   /**
  507.    * Initialize a specific SourceBuffer.
  508.    *
  509.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  510.    * @param {shaka.extern.Stream} stream
  511.    * @param {string} codecs
  512.    * @return {!Promise}
  513.    * @private
  514.    */
  515.   async initSourceBuffer_(contentType, stream, codecs) {
  516.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  518.     goog.asserts.assert(
  519.         await shaka.media.MediaSourceEngine.isStreamSupported(
  520.             stream, contentType),
  521.         'Type negotiation should happen before MediaSourceEngine.init!');
  523.     let mimeType = shaka.util.MimeUtils.getFullType(
  524.         stream.mimeType, codecs);
  525.     if (contentType == ContentType.TEXT) {
  526.       this.reinitText(mimeType, this.sequenceMode_, stream.external);
  527.     } else {
  528.       let needTransmux = this.config_.forceTransmux;
  529.       if (!shaka.media.Capabilities.isTypeSupported(mimeType) ||
  530.           (!this.sequenceMode_ &&
  531.           shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType))) {
  532.         needTransmux = true;
  533.       }
  534.       const mimeTypeWithAllCodecs =
  535.           shaka.util.MimeUtils.getFullTypeWithAllCodecs(
  536.               stream.mimeType, codecs);
  537.       if (needTransmux) {
  538.         const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  539.             ContentType.AUDIO, (codecs || '').split(','));
  540.         const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  541.             ContentType.VIDEO, (codecs || '').split(','));
  542.         if (audioCodec && videoCodec) {
  543.           this.needSplitMuxedContent_ = true;
  544.           await this.initSourceBuffer_(ContentType.AUDIO, stream, audioCodec);
  545.           await this.initSourceBuffer_(ContentType.VIDEO, stream, videoCodec);
  546.           return;
  547.         }
  548.         const transmuxerPlugin = shaka.transmuxer.TransmuxerEngine
  549.             .findTransmuxer(mimeTypeWithAllCodecs);
  550.         if (transmuxerPlugin) {
  551.           const transmuxer = transmuxerPlugin();
  552.           this.transmuxers_[contentType] = transmuxer;
  553.           mimeType =
  554.               transmuxer.convertCodecs(contentType, mimeTypeWithAllCodecs);
  555.         }
  556.       }
  557.       const type = this.addExtraFeaturesToMimeType_(mimeType);
  559.       this.destroyer_.ensureNotDestroyed();
  561.       let sourceBuffer;
  563.       try {
  564.         sourceBuffer = this.mediaSource_.addSourceBuffer(type);
  565.       } catch (exception) {
  566.         throw new shaka.util.Error(
  567.             shaka.util.Error.Severity.CRITICAL,
  568.             shaka.util.Error.Category.MEDIA,
  569.             shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  570.             exception,
  571.             'The mediaSource_ status was ' + this.mediaSource_.readyState +
  572.             ' expected \'open\'');
  573.       }
  575.       if (this.sequenceMode_) {
  576.         sourceBuffer.mode =
  577.             shaka.media.MediaSourceEngine.SourceBufferMode_.SEQUENCE;
  578.       }
  580.       this.eventManager_.listen(
  581.           sourceBuffer, 'error',
  582.           () => this.onError_(contentType));
  583.       this.eventManager_.listen(
  584.           sourceBuffer, 'updateend',
  585.           () => this.onUpdateEnd_(contentType));
  586.       this.sourceBuffers_[contentType] = sourceBuffer;
  587.       this.sourceBufferTypes_[contentType] = mimeType;
  588.       this.expectedEncryption_[contentType] = !!stream.drmInfos.length;
  589.     }
  590.   }
  592.   /**
  593.    * Called by the Player to provide an updated configuration any time it
  594.    * changes. Must be called at least once before init().
  595.    *
  596.    * @param {shaka.extern.MediaSourceConfiguration} config
  597.    */
  598.   configure(config) {
  599.     this.config_ = config;
  600.     if (this.textEngine_) {
  601.       this.textEngine_.setModifyCueCallback(config.modifyCueCallback);
  602.     }
  603.   }
  605.   /**
  606.    * Indicate if the streaming is allowed by MediaSourceEngine.
  607.    * If we using MediaSource we allways returns true.
  608.    *
  609.    * @return {boolean}
  610.    */
  611.   isStreamingAllowed() {
  612.     return this.streamingAllowed_;
  613.   }
  615.   /**
  616.    * Reinitialize the TextEngine for a new text type.
  617.    * @param {string} mimeType
  618.    * @param {boolean} sequenceMode
  619.    * @param {boolean} external
  620.    */
  621.   reinitText(mimeType, sequenceMode, external) {
  622.     if (!this.textEngine_) {
  623.       this.textEngine_ = new shaka.text.TextEngine(this.textDisplayer_);
  624.       if (this.textEngine_) {
  625.         this.textEngine_.setModifyCueCallback(this.config_.modifyCueCallback);
  626.       }
  627.     }
  628.     this.textEngine_.initParser(mimeType, sequenceMode,
  629.         external || this.segmentRelativeVttTiming_, this.manifestType_);
  630.   }
  632.   /**
  633.    * @return {boolean} True if the MediaSource is in an "ended" state, or if the
  634.    *   object has been destroyed.
  635.    */
  636.   ended() {
  637.     if (this.reloadingMediaSource_) {
  638.       return false;
  639.     }
  640.     return this.mediaSource_ ? this.mediaSource_.readyState == 'ended' : true;
  641.   }
  643.   /**
  644.    * Gets the first timestamp in buffer for the given content type.
  645.    *
  646.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  647.    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  648.    */
  649.   bufferStart(contentType) {
  650.     if (this.reloadingMediaSource_ ||
  651.           !Object.keys(this.sourceBuffers_).length) {
  652.       return null;
  653.     }
  654.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  655.     if (contentType == ContentType.TEXT) {
  656.       return this.textEngine_.bufferStart();
  657.     }
  658.     return shaka.media.TimeRangesUtils.bufferStart(
  659.         this.getBuffered_(contentType));
  660.   }
  662.   /**
  663.    * Gets the last timestamp in buffer for the given content type.
  664.    *
  665.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  666.    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  667.    */
  668.   bufferEnd(contentType) {
  669.     if (this.reloadingMediaSource_) {
  670.       return null;
  671.     }
  672.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  673.     if (contentType == ContentType.TEXT) {
  674.       return this.textEngine_.bufferEnd();
  675.     }
  676.     return shaka.media.TimeRangesUtils.bufferEnd(
  677.         this.getBuffered_(contentType));
  678.   }
  680.   /**
  681.    * Determines if the given time is inside the buffered range of the given
  682.    * content type.
  683.    *
  684.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  685.    * @param {number} time Playhead time
  686.    * @return {boolean}
  687.    */
  688.   isBuffered(contentType, time) {
  689.     if (this.reloadingMediaSource_) {
  690.       return false;
  691.     }
  692.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  693.     if (contentType == ContentType.TEXT) {
  694.       return this.textEngine_.isBuffered(time);
  695.     } else {
  696.       const buffered = this.getBuffered_(contentType);
  697.       return shaka.media.TimeRangesUtils.isBuffered(buffered, time);
  698.     }
  699.   }
  701.   /**
  702.    * Computes how far ahead of the given timestamp is buffered for the given
  703.    * content type.
  704.    *
  705.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  706.    * @param {number} time
  707.    * @return {number} The amount of time buffered ahead in seconds.
  708.    */
  709.   bufferedAheadOf(contentType, time) {
  710.     if (this.reloadingMediaSource_) {
  711.       return 0;
  712.     }
  713.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  714.     if (contentType == ContentType.TEXT) {
  715.       return this.textEngine_.bufferedAheadOf(time);
  716.     } else {
  717.       const buffered = this.getBuffered_(contentType);
  718.       return shaka.media.TimeRangesUtils.bufferedAheadOf(buffered, time);
  719.     }
  720.   }
  722.   /**
  723.    * Returns info about what is currently buffered.
  724.    * @return {shaka.extern.BufferedInfo}
  725.    */
  726.   getBufferedInfo() {
  727.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  728.     const TimeRangesUtils = shaka.media.TimeRangesUtils;
  730.     const info = {
  731.       total: this.reloadingMediaSource_ ? [] :
  732.         TimeRangesUtils.getBufferedInfo(this.video_.buffered),
  733.       audio: this.reloadingMediaSource_ ? [] :
  734.         TimeRangesUtils.getBufferedInfo(this.getBuffered_(ContentType.AUDIO)),
  735.       video: this.reloadingMediaSource_ ? [] :
  736.         TimeRangesUtils.getBufferedInfo(this.getBuffered_(ContentType.VIDEO)),
  737.       text: [],
  738.     };
  740.     if (this.textEngine_) {
  741.       const start = this.textEngine_.bufferStart();
  742.       const end = this.textEngine_.bufferEnd();
  744.       if (start != null && end != null) {
  745.         info.text.push({start: start, end: end});
  746.       }
  747.     }
  748.     return info;
  749.   }
  751.   /**
  752.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  753.    * @return {TimeRanges} The buffered ranges for the given content type, or
  754.    *   null if the buffered ranges could not be obtained.
  755.    * @private
  756.    */
  757.   getBuffered_(contentType) {
  758.     try {
  759.       return this.sourceBuffers_[contentType].buffered;
  760.     } catch (exception) {
  761.       if (contentType in this.sourceBuffers_) {
  762.         // Note: previous MediaSource errors may cause access to |buffered| to
  763.         // throw.
  764.         shaka.log.error('failed to get buffered range for ' + contentType,
  765.             exception);
  766.       }
  767.       return null;
  768.     }
  769.   }
  771.   /**
  772.    * Create a new closed caption parser. This will ONLY be replaced by tests as
  773.    * a way to inject fake closed caption parser instances.
  774.    *
  775.    * @param {string} mimeType
  776.    * @return {!shaka.media.IClosedCaptionParser}
  777.    */
  778.   getCaptionParser(mimeType) {
  779.     return new shaka.media.ClosedCaptionParser(mimeType);
  780.   }
  782.   /**
  783.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  784.    * @param {!BufferSource} data
  785.    * @param {?shaka.media.SegmentReference} reference The segment reference
  786.    *   we are appending, or null for init segments
  787.    * @param {!string} mimeType
  788.    * @param {!number} timestampOffset
  789.    * @return {?number}
  790.    * @private
  791.    */
  792.   getTimestampAndDispatchMetadata_(contentType, data, reference, mimeType,
  793.       timestampOffset) {
  794.     let timestamp = null;
  796.     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
  797.     if (shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType)) {
  798.       const frames = shaka.util.Id3Utils.getID3Frames(uint8ArrayData);
  799.       if (frames.length && reference) {
  800.         const metadataTimestamp = frames.find((frame) => {
  801.           return frame.description ===
  802.               'com.apple.streaming.transportStreamTimestamp';
  803.         });
  804.         if (metadataTimestamp && metadataTimestamp.data) {
  805.           timestamp = Math.round(metadataTimestamp.data) / 1000;
  806.         }
  807.         /** @private {shaka.extern.ID3Metadata} */
  808.         const metadata = {
  809.           cueTime: reference.startTime,
  810.           data: uint8ArrayData,
  811.           frames: frames,
  812.           dts: reference.startTime,
  813.           pts: reference.startTime,
  814.         };
  815.         this.onMetadata_([metadata], /* offset= */ 0, reference.endTime);
  816.       }
  817.     } else if (mimeType.includes('/mp4') &&
  818.         reference && reference.timestampOffset == 0 &&
  819.         reference.initSegmentReference &&
  820.         reference.initSegmentReference.timescale) {
  821.       const timescale = reference.initSegmentReference.timescale;
  822.       if (!isNaN(timescale)) {
  823.         const Mp4Parser = shaka.util.Mp4Parser;
  824.         let startTime = 0;
  825.         let parsedMedia = false;
  826.         new Mp4Parser()
  827.             .box('moof', Mp4Parser.children)
  828.             .box('traf', Mp4Parser.children)
  829.             .fullBox('tfdt', (box) => {
  830.               goog.asserts.assert(
  831.                   box.version == 0 || box.version == 1,
  832.                   'TFDT version can only be 0 or 1');
  833.               const parsed = shaka.util.Mp4BoxParsers.parseTFDTInaccurate(
  834.                   box.reader, box.version);
  835.               startTime = parsed.baseMediaDecodeTime / timescale;
  836.               parsedMedia = true;
  837.               box.parser.stop();
  838.             }).parse(data, /* partialOkay= */ true);
  839.         if (parsedMedia) {
  840.           timestamp = startTime;
  841.         }
  842.       }
  843.     } else if (!mimeType.includes('/mp4') && !mimeType.includes('/webm') &&
  844.         shaka.util.TsParser.probe(uint8ArrayData)) {
  845.       if (!this.tsParser_) {
  846.         this.tsParser_ = new shaka.util.TsParser();
  847.       } else {
  848.         this.tsParser_.clearData();
  849.       }
  850.       const tsParser = this.tsParser_.parse(uint8ArrayData);
  851.       const startTime = tsParser.getStartTime(contentType);
  852.       if (startTime != null) {
  853.         timestamp = startTime;
  854.       }
  855.       const metadata = tsParser.getMetadata();
  856.       if (metadata.length) {
  857.         this.onMetadata_(metadata, timestampOffset,
  858.             reference ? reference.endTime : null);
  859.       }
  860.     }
  861.     return timestamp;
  862.   }
  864.   /**
  865.    * Enqueue an operation to append data to the SourceBuffer.
  866.    * Start and end times are needed for TextEngine, but not for MediaSource.
  867.    * Start and end times may be null for initialization segments; if present
  868.    * they are relative to the presentation timeline.
  869.    *
  870.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  871.    * @param {!BufferSource} data
  872.    * @param {?shaka.media.SegmentReference} reference The segment reference
  873.    *   we are appending, or null for init segments
  874.    * @param {shaka.extern.Stream} stream
  875.    * @param {?boolean} hasClosedCaptions True if the buffer contains CEA closed
  876.    *   captions
  877.    * @param {boolean=} seeked True if we just seeked
  878.    * @param {boolean=} adaptation True if we just automatically switched active
  879.    *   variant(s).
  880.    * @param {boolean=} isChunkedData True if we add to the buffer from the
  881.    *   partial read of the segment.
  882.    * @return {!Promise}
  883.    */
  884.   async appendBuffer(
  885.       contentType, data, reference, stream, hasClosedCaptions, seeked = false,
  886.       adaptation = false, isChunkedData = false, fromSplit = false) {
  887.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  889.     if (contentType == ContentType.TEXT) {
  890.       if (this.sequenceMode_) {
  891.         // This won't be known until the first video segment is appended.
  892.         const offset = await this.textSequenceModeOffset_;
  893.         this.textEngine_.setTimestampOffset(offset);
  894.       }
  895.       await this.textEngine_.appendBuffer(
  896.           data,
  897.           reference ? reference.startTime : null,
  898.           reference ? reference.endTime : null,
  899.           reference ? reference.getUris()[0] : null);
  900.       return;
  901.     }
  903.     if (!fromSplit && this.needSplitMuxedContent_) {
  904.       await this.appendBuffer(ContentType.AUDIO, data, reference, stream,
  905.           hasClosedCaptions, seeked, adaptation, isChunkedData,
  906.           /* fromSplit= */ true);
  907.       await this.appendBuffer(ContentType.VIDEO, data, reference, stream,
  908.           hasClosedCaptions, seeked, adaptation, isChunkedData,
  909.           /* fromSplit= */ true);
  910.       return;
  911.     }
  913.     if (!this.sourceBuffers_[contentType]) {
  914.       shaka.log.warning('Attempted to restore a non-existent source buffer');
  915.       return;
  916.     }
  918.     let timestampOffset = this.sourceBuffers_[contentType].timestampOffset;
  920.     let mimeType = this.sourceBufferTypes_[contentType];
  921.     if (this.transmuxers_[contentType]) {
  922.       mimeType = this.transmuxers_[contentType].getOriginalMimeType();
  923.     }
  924.     if (reference) {
  925.       const timestamp = this.getTimestampAndDispatchMetadata_(
  926.           contentType, data, reference, mimeType, timestampOffset);
  927.       if (timestamp != null) {
  928.         const calculatedTimestampOffset = reference.startTime - timestamp;
  929.         const timestampOffsetDifference =
  930.             Math.abs(timestampOffset - calculatedTimestampOffset);
  931.         if ((timestampOffsetDifference >= 0.001 || seeked || adaptation) &&
  932.             (!isChunkedData || calculatedTimestampOffset > 0 ||
  933.             !timestampOffset)) {
  934.           timestampOffset = calculatedTimestampOffset;
  935.           if (this.attemptTimestampOffsetCalculation_) {
  936.             this.enqueueOperation_(
  937.                 contentType,
  938.                 () => this.abort_(contentType));
  939.             this.enqueueOperation_(
  940.                 contentType,
  941.                 () => this.setTimestampOffset_(contentType, timestampOffset));
  942.           }
  943.         }
  944.         // Timestamps can only be reliably extracted from video, not audio.
  945.         // Packed audio formats do not have internal timestamps at all.
  946.         // Prefer video for this when available.
  947.         const isBestSourceBufferForTimestamps =
  948.             contentType == ContentType.VIDEO ||
  949.             !(ContentType.VIDEO in this.sourceBuffers_);
  950.         if (this.sequenceMode_ && isBestSourceBufferForTimestamps) {
  951.           this.textSequenceModeOffset_.resolve(timestampOffset);
  952.         }
  953.       }
  954.     }
  955.     if (hasClosedCaptions && contentType == ContentType.VIDEO) {
  956.       if (!this.textEngine_) {
  957.         this.reinitText(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE,
  958.             this.sequenceMode_, /* external= */ false);
  959.       }
  960.       if (!this.captionParser_) {
  961.         const basicType = mimeType.split(';', 1)[0];
  962.         this.captionParser_ = this.getCaptionParser(basicType);
  963.       }
  964.       // If it is the init segment for closed captions, initialize the closed
  965.       // caption parser.
  966.       if (!reference) {
  967.         this.captionParser_.init(data, adaptation);
  968.       } else {
  969.         const closedCaptions = this.captionParser_.parseFrom(data);
  970.         if (closedCaptions.length) {
  971.           this.textEngine_.storeAndAppendClosedCaptions(
  972.               closedCaptions,
  973.               reference.startTime,
  974.               reference.endTime,
  975.               timestampOffset);
  976.         }
  977.       }
  978.     }
  980.     if (this.transmuxers_[contentType]) {
  981.       data = await this.transmuxers_[contentType].transmux(
  982.           data, stream, reference, this.mediaSource_.duration, contentType);
  983.     }
  985.     data = this.workAroundBrokenPlatforms_(
  986.         data, reference ? reference.startTime : null, contentType);
  988.     if (reference && this.sequenceMode_ && contentType != ContentType.TEXT) {
  989.       // In sequence mode, for non-text streams, if we just cleared the buffer
  990.       // and are either performing an unbuffered seek or handling an automatic
  991.       // adaptation, we need to set a new timestampOffset on the sourceBuffer.
  992.       if (seeked || adaptation) {
  993.         const timestampOffset = reference.startTime;
  994.         // The logic to call abort() before setting the timestampOffset is
  995.         // extended during unbuffered seeks or automatic adaptations; it is
  996.         // possible for the append state to be PARSING_MEDIA_SEGMENT from the
  997.         // previous SourceBuffer#appendBuffer() call.
  998.         this.enqueueOperation_(contentType, () => this.abort_(contentType));
  999.         this.enqueueOperation_(
  1000.             contentType,
  1001.             () => this.setTimestampOffset_(contentType, timestampOffset));
  1002.       }
  1003.     }
  1005.     let bufferedBefore = null;
  1007.     await this.enqueueOperation_(contentType, () => {
  1008.       if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
  1009.         bufferedBefore = this.getBuffered_(contentType);
  1010.       }
  1011.       this.append_(contentType, data, timestampOffset);
  1012.     });
  1014.     if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
  1015.       const bufferedAfter = this.getBuffered_(contentType);
  1016.       const newBuffered = shaka.media.TimeRangesUtils.computeAddedRange(
  1017.           bufferedBefore, bufferedAfter);
  1018.       if (newBuffered) {
  1019.         const segmentDuration = reference.endTime - reference.startTime;
  1020.         // Check end times instead of start times.  We may be overwriting a
  1021.         // buffer and only the end changes, and that would be fine.
  1022.         // Also, exclude tiny segments.  Sometimes alignment segments as small
  1023.         // as 33ms are seen in Google DAI content.  For such tiny segments,
  1024.         // half a segment duration would be no issue.
  1025.         const offset = Math.abs(newBuffered.end - reference.endTime);
  1026.         if (segmentDuration > 0.100 && offset > segmentDuration / 2) {
  1027.           shaka.log.error('Possible encoding problem detected!',
  1028.               'Unexpected buffered range for reference', reference,
  1029.               'from URIs', reference.getUris(),
  1030.               'should be', {start: reference.startTime, end: reference.endTime},
  1031.               'but got', newBuffered);
  1032.         }
  1033.       }
  1034.     }
  1035.   }
  1037.   /**
  1038.    * Set the selected closed captions Id and language.
  1039.    *
  1040.    * @param {string} id
  1041.    */
  1042.   setSelectedClosedCaptionId(id) {
  1043.     const VIDEO = shaka.util.ManifestParserUtils.ContentType.VIDEO;
  1044.     const videoBufferEndTime = this.bufferEnd(VIDEO) || 0;
  1045.     this.textEngine_.setSelectedClosedCaptionId(id, videoBufferEndTime);
  1046.   }
  1048.   /** Disable embedded closed captions. */
  1049.   clearSelectedClosedCaptionId() {
  1050.     if (this.textEngine_) {
  1051.       this.textEngine_.setSelectedClosedCaptionId('', 0);
  1052.     }
  1053.   }
  1055.   /**
  1056.    * Enqueue an operation to remove data from the SourceBuffer.
  1057.    *
  1058.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1059.    * @param {number} startTime relative to the start of the presentation
  1060.    * @param {number} endTime relative to the start of the presentation
  1061.    * @return {!Promise}
  1062.    */
  1063.   async remove(contentType, startTime, endTime) {
  1064.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1065.     if (contentType == ContentType.TEXT) {
  1066.       await this.textEngine_.remove(startTime, endTime);
  1067.     } else {
  1068.       await this.enqueueOperation_(
  1069.           contentType,
  1070.           () => this.remove_(contentType, startTime, endTime));
  1071.       if (this.needSplitMuxedContent_) {
  1072.         await this.enqueueOperation_(
  1073.             ContentType.AUDIO,
  1074.             () => this.remove_(ContentType.AUDIO, startTime, endTime));
  1075.       }
  1076.     }
  1077.   }
  1079.   /**
  1080.    * Enqueue an operation to clear the SourceBuffer.
  1081.    *
  1082.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1083.    * @return {!Promise}
  1084.    */
  1085.   async clear(contentType) {
  1086.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1087.     if (contentType == ContentType.TEXT) {
  1088.       if (!this.textEngine_) {
  1089.         return;
  1090.       }
  1091.       await this.textEngine_.remove(0, Infinity);
  1092.     } else {
  1093.       // Note that not all platforms allow clearing to Infinity.
  1094.       await this.enqueueOperation_(
  1095.           contentType,
  1096.           () => this.remove_(contentType, 0, this.mediaSource_.duration));
  1097.       if (this.needSplitMuxedContent_) {
  1098.         await this.enqueueOperation_(
  1099.             ContentType.AUDIO,
  1100.             () => this.remove_(
  1101.                 ContentType.AUDIO, 0, this.mediaSource_.duration));
  1102.       }
  1103.     }
  1104.   }
  1106.   /**
  1107.    * Fully reset the state of the caption parser owned by MediaSourceEngine.
  1108.    */
  1109.   resetCaptionParser() {
  1110.     if (this.captionParser_) {
  1111.       this.captionParser_.reset();
  1112.     }
  1113.   }
  1115.   /**
  1116.    * Enqueue an operation to flush the SourceBuffer.
  1117.    * This is a workaround for what we believe is a Chromecast bug.
  1118.    *
  1119.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1120.    * @return {!Promise}
  1121.    */
  1122.   async flush(contentType) {
  1123.     // Flush the pipeline.  Necessary on Chromecast, even though we have removed
  1124.     // everything.
  1125.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1126.     if (contentType == ContentType.TEXT) {
  1127.       // Nothing to flush for text.
  1128.       return;
  1129.     }
  1130.     await this.enqueueOperation_(
  1131.         contentType,
  1132.         () => this.flush_(contentType));
  1133.     if (this.needSplitMuxedContent_) {
  1134.       await this.enqueueOperation_(
  1135.           ContentType.AUDIO,
  1136.           () => this.flush_(ContentType.AUDIO));
  1137.     }
  1138.   }
  1140.   /**
  1141.    * Sets the timestamp offset and append window end for the given content type.
  1142.    *
  1143.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1144.    * @param {number} timestampOffset The timestamp offset.  Segments which start
  1145.    *   at time t will be inserted at time t + timestampOffset instead.  This
  1146.    *   value does not affect segments which have already been inserted.
  1147.    * @param {number} appendWindowStart The timestamp to set the append window
  1148.    *   start to.  For future appends, frames/samples with timestamps less than
  1149.    *   this value will be dropped.
  1150.    * @param {number} appendWindowEnd The timestamp to set the append window end
  1151.    *   to.  For future appends, frames/samples with timestamps greater than this
  1152.    *   value will be dropped.
  1153.    * @param {boolean} ignoreTimestampOffset  If true, the timestampOffset will
  1154.    *   not be applied in this step.
  1155.    * @param {string} mimeType
  1156.    * @param {string} codecs
  1157.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  1158.    *               shaka.extern.Stream>} streamsByType
  1159.    *   A map of content types to streams.  All streams must be supported
  1160.    *   according to MediaSourceEngine.isStreamSupported.
  1161.    *
  1162.    * @return {!Promise}
  1163.    */
  1164.   async setStreamProperties(
  1165.       contentType, timestampOffset, appendWindowStart, appendWindowEnd,
  1166.       ignoreTimestampOffset, mimeType, codecs, streamsByType) {
  1167.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1168.     if (contentType == ContentType.TEXT) {
  1169.       if (!ignoreTimestampOffset) {
  1170.         this.textEngine_.setTimestampOffset(timestampOffset);
  1171.       }
  1172.       this.textEngine_.setAppendWindow(appendWindowStart, appendWindowEnd);
  1173.       return;
  1174.     }
  1175.     const operations = [];
  1177.     const hasChangedCodecs = await this.codecSwitchIfNecessary_(
  1178.         contentType, mimeType, codecs, streamsByType);
  1180.     if (!hasChangedCodecs) {
  1181.       // Queue an abort() to help MSE splice together overlapping segments.
  1182.       // We set appendWindowEnd when we change periods in DASH content, and the
  1183.       // period transition may result in overlap.
  1184.       //
  1185.       // An abort() also helps with MPEG2-TS.  When we append a TS segment, we
  1186.       // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
  1187.       // timestamp offset.  By calling abort(), we reset the state so we can
  1188.       // set it.
  1189.       operations.push(this.enqueueOperation_(
  1190.           contentType,
  1191.           () => this.abort_(contentType)));
  1192.       if (this.needSplitMuxedContent_) {
  1193.         operations.push(this.enqueueOperation_(
  1194.             ContentType.AUDIO,
  1195.             () => this.abort_(ContentType.AUDIO)));
  1196.       }
  1197.     }
  1198.     if (!ignoreTimestampOffset) {
  1199.       operations.push(this.enqueueOperation_(
  1200.           contentType,
  1201.           () => this.setTimestampOffset_(contentType, timestampOffset)));
  1202.       if (this.needSplitMuxedContent_) {
  1203.         operations.push(this.enqueueOperation_(
  1204.             ContentType.AUDIO,
  1205.             () => this.setTimestampOffset_(
  1206.                 ContentType.AUDIO, timestampOffset)));
  1207.       }
  1208.     }
  1209.     operations.push(this.enqueueOperation_(
  1210.         contentType,
  1211.         () => this.setAppendWindow_(
  1212.             contentType, appendWindowStart, appendWindowEnd)));
  1213.     if (this.needSplitMuxedContent_) {
  1214.       operations.push(this.enqueueOperation_(
  1215.           ContentType.AUDIO,
  1216.           () => this.setAppendWindow_(
  1217.               ContentType.AUDIO, appendWindowStart, appendWindowEnd)));
  1218.     }
  1220.     await Promise.all(operations);
  1221.   }
  1223.   /**
  1224.    * Adjust timestamp offset to maintain AV sync across discontinuities.
  1225.    *
  1226.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1227.    * @param {number} timestampOffset
  1228.    * @return {!Promise}
  1229.    */
  1230.   async resync(contentType, timestampOffset) {
  1231.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1233.     if (contentType == ContentType.TEXT) {
  1234.       // This operation is for audio and video only.
  1235.       return;
  1236.     }
  1238.     // Reset the promise in case the timestamp offset changed during
  1239.     // a period/discontinuity transition.
  1240.     if (contentType == ContentType.VIDEO) {
  1241.       this.textSequenceModeOffset_ = new shaka.util.PublicPromise();
  1242.     }
  1244.     // Queue an abort() to help MSE splice together overlapping segments.
  1245.     // We set appendWindowEnd when we change periods in DASH content, and the
  1246.     // period transition may result in overlap.
  1247.     //
  1248.     // An abort() also helps with MPEG2-TS.  When we append a TS segment, we
  1249.     // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
  1250.     // timestamp offset.  By calling abort(), we reset the state so we can
  1251.     // set it.
  1252.     this.enqueueOperation_(
  1253.         contentType,
  1254.         () => this.abort_(contentType));
  1255.     if (this.needSplitMuxedContent_) {
  1256.       this.enqueueOperation_(
  1257.           ContentType.AUDIO,
  1258.           () => this.abort_(ContentType.AUDIO));
  1259.     }
  1260.     await this.enqueueOperation_(
  1261.         contentType,
  1262.         () => this.setTimestampOffset_(contentType, timestampOffset));
  1263.     if (this.needSplitMuxedContent_) {
  1264.       await this.enqueueOperation_(
  1265.           ContentType.AUDIO,
  1266.           () => this.setTimestampOffset_(ContentType.AUDIO, timestampOffset));
  1267.     }
  1268.   }
  1270.   /**
  1271.    * @param {string=} reason Valid reasons are 'network' and 'decode'.
  1272.    * @return {!Promise}
  1273.    * @see http://w3c.github.io/media-source/#idl-def-EndOfStreamError
  1274.    */
  1275.   async endOfStream(reason) {
  1276.     await this.enqueueBlockingOperation_(() => {
  1277.       // If endOfStream() has already been called on the media source,
  1278.       // don't call it again. Also do not call if readyState is
  1279.       // 'closed' (not attached to video element) since it is not a
  1280.       // valid operation.
  1281.       if (this.ended() || this.mediaSource_.readyState === 'closed') {
  1282.         return;
  1283.       }
  1284.       // Tizen won't let us pass undefined, but it will let us omit the
  1285.       // argument.
  1286.       if (reason) {
  1287.         this.mediaSource_.endOfStream(reason);
  1288.       } else {
  1289.         this.mediaSource_.endOfStream();
  1290.       }
  1291.     });
  1292.   }
  1294.   /**
  1295.    * @param {number} duration
  1296.    * @return {!Promise}
  1297.    */
  1298.   async setDuration(duration) {
  1299.     await this.enqueueBlockingOperation_(() => {
  1300.       // Reducing the duration causes the MSE removal algorithm to run, which
  1301.       // triggers an 'updateend' event to fire.  To handle this scenario, we
  1302.       // have to insert a dummy operation into the beginning of each queue,
  1303.       // which the 'updateend' handler will remove.
  1304.       if (duration < this.mediaSource_.duration) {
  1305.         for (const contentType in this.sourceBuffers_) {
  1306.           const dummyOperation = {
  1307.             start: () => {},
  1308.             p: new shaka.util.PublicPromise(),
  1309.           };
  1310.           this.queues_[contentType].unshift(dummyOperation);
  1311.         }
  1312.       }
  1314.       this.mediaSource_.duration = duration;
  1315.       this.lastDuration_ = duration;
  1316.     });
  1317.   }
  1319.   /**
  1320.    * Get the current MediaSource duration.
  1321.    *
  1322.    * @return {number}
  1323.    */
  1324.   getDuration() {
  1325.     return this.mediaSource_.duration;
  1326.   }
  1328.   /**
  1329.    * Append data to the SourceBuffer.
  1330.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1331.    * @param {BufferSource} data
  1332.    * @param {number} timestampOffset
  1333.    * @private
  1334.    */
  1335.   append_(contentType, data, timestampOffset) {
  1336.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1338.     // Append only video data to the LCEVC Dec.
  1339.     if (contentType == ContentType.VIDEO && this.lcevcDec_) {
  1340.       // Append video buffers to the LCEVC Dec for parsing and storing
  1341.       // of LCEVC data.
  1342.       this.lcevcDec_.appendBuffer(data, timestampOffset);
  1343.     }
  1345.     // This will trigger an 'updateend' event.
  1346.     this.sourceBuffers_[contentType].appendBuffer(data);
  1347.   }
  1349.   /**
  1350.    * Remove data from the SourceBuffer.
  1351.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1352.    * @param {number} startTime relative to the start of the presentation
  1353.    * @param {number} endTime relative to the start of the presentation
  1354.    * @private
  1355.    */
  1356.   remove_(contentType, startTime, endTime) {
  1357.     if (endTime <= startTime) {
  1358.       // Ignore removal of inverted or empty ranges.
  1359.       // Fake 'updateend' event to resolve the operation.
  1360.       this.onUpdateEnd_(contentType);
  1361.       return;
  1362.     }
  1364.     // This will trigger an 'updateend' event.
  1365.     this.sourceBuffers_[contentType].remove(startTime, endTime);
  1366.   }
  1368.   /**
  1369.    * Call abort() on the SourceBuffer.
  1370.    * This resets MSE's last_decode_timestamp on all track buffers, which should
  1371.    * trigger the splicing logic for overlapping segments.
  1372.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1373.    * @private
  1374.    */
  1375.   abort_(contentType) {
  1376.     // Save the append window, which is reset on abort().
  1377.     const appendWindowStart =
  1378.         this.sourceBuffers_[contentType].appendWindowStart;
  1379.     const appendWindowEnd = this.sourceBuffers_[contentType].appendWindowEnd;
  1381.     // This will not trigger an 'updateend' event, since nothing is happening.
  1382.     // This is only to reset MSE internals, not to abort an actual operation.
  1383.     this.sourceBuffers_[contentType].abort();
  1385.     // Restore the append window.
  1386.     this.sourceBuffers_[contentType].appendWindowStart = appendWindowStart;
  1387.     this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
  1389.     // Fake an 'updateend' event to resolve the operation.
  1390.     this.onUpdateEnd_(contentType);
  1391.   }
  1393.   /**
  1394.    * Nudge the playhead to force the media pipeline to be flushed.
  1395.    * This seems to be necessary on Chromecast to get new content to replace old
  1396.    * content.
  1397.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1398.    * @private
  1399.    */
  1400.   flush_(contentType) {
  1401.     // Never use flush_ if there's data.  It causes a hiccup in playback.
  1402.     goog.asserts.assert(
  1403.         this.video_.buffered.length == 0, 'MediaSourceEngine.flush_ should ' +
  1404.         'only be used after clearing all data!');
  1406.     // Seeking forces the pipeline to be flushed.
  1407.     this.video_.currentTime -= 0.001;
  1409.     // Fake an 'updateend' event to resolve the operation.
  1410.     this.onUpdateEnd_(contentType);
  1411.   }
  1413.   /**
  1414.    * Set the SourceBuffer's timestamp offset.
  1415.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1416.    * @param {number} timestampOffset
  1417.    * @private
  1418.    */
  1419.   setTimestampOffset_(contentType, timestampOffset) {
  1420.     // Work around for
  1421.     // https://github.com/shaka-project/shaka-player/issues/1281:
  1422.     // TODO(https://bit.ly/2ttKiBU): follow up when this is fixed in Edge
  1423.     if (timestampOffset < 0) {
  1424.       // Try to prevent rounding errors in Edge from removing the first
  1425.       // keyframe.
  1426.       timestampOffset += 0.001;
  1427.     }
  1429.     this.sourceBuffers_[contentType].timestampOffset = timestampOffset;
  1431.     // Fake an 'updateend' event to resolve the operation.
  1432.     this.onUpdateEnd_(contentType);
  1433.   }
  1435.   /**
  1436.    * Set the SourceBuffer's append window end.
  1437.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1438.    * @param {number} appendWindowStart
  1439.    * @param {number} appendWindowEnd
  1440.    * @private
  1441.    */
  1442.   setAppendWindow_(contentType, appendWindowStart, appendWindowEnd) {
  1443.     // You can't set start > end, so first set start to 0, then set the new
  1444.     // end, then set the new start.  That way, there are no intermediate
  1445.     // states which are invalid.
  1446.     this.sourceBuffers_[contentType].appendWindowStart = 0;
  1447.     this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
  1448.     this.sourceBuffers_[contentType].appendWindowStart = appendWindowStart;
  1450.     // Fake an 'updateend' event to resolve the operation.
  1451.     this.onUpdateEnd_(contentType);
  1452.   }
  1454.   /**
  1455.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1456.    * @private
  1457.    */
  1458.   onError_(contentType) {
  1459.     const operation = this.queues_[contentType][0];
  1460.     goog.asserts.assert(operation, 'Spurious error event!');
  1461.     goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
  1462.         'SourceBuffer should not be updating on error!');
  1463.     const code = this.video_.error ? this.video_.error.code : 0;
  1464.     operation.p.reject(new shaka.util.Error(
  1465.         shaka.util.Error.Severity.CRITICAL,
  1466.         shaka.util.Error.Category.MEDIA,
  1467.         shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_FAILED,
  1468.         code));
  1469.     // Do not pop from queue.  An 'updateend' event will fire next, and to
  1470.     // avoid synchronizing these two event handlers, we will allow that one to
  1471.     // pop from the queue as normal.  Note that because the operation has
  1472.     // already been rejected, the call to resolve() in the 'updateend' handler
  1473.     // will have no effect.
  1474.   }
  1476.   /**
  1477.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1478.    * @private
  1479.    */
  1480.   onUpdateEnd_(contentType) {
  1481.     if (this.reloadingMediaSource_) {
  1482.       return;
  1483.     }
  1484.     const operation = this.queues_[contentType][0];
  1485.     goog.asserts.assert(operation, 'Spurious updateend event!');
  1486.     if (!operation) {
  1487.       return;
  1488.     }
  1489.     goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
  1490.         'SourceBuffer should not be updating on updateend!');
  1491.     operation.p.resolve();
  1492.     this.popFromQueue_(contentType);
  1493.   }
  1495.   /**
  1496.    * Enqueue an operation and start it if appropriate.
  1497.    *
  1498.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1499.    * @param {function()} start
  1500.    * @return {!Promise}
  1501.    * @private
  1502.    */
  1503.   enqueueOperation_(contentType, start) {
  1504.     this.destroyer_.ensureNotDestroyed();
  1505.     const operation = {
  1506.       start: start,
  1507.       p: new shaka.util.PublicPromise(),
  1508.     };
  1509.     this.queues_[contentType].push(operation);
  1511.     if (this.queues_[contentType].length == 1) {
  1512.       this.startOperation_(contentType);
  1513.     }
  1514.     return operation.p;
  1515.   }
  1517.   /**
  1518.    * Enqueue an operation which must block all other operations on all
  1519.    * SourceBuffers.
  1520.    *
  1521.    * @param {function():(Promise|undefined)} run
  1522.    * @return {!Promise}
  1523.    * @private
  1524.    */
  1525.   async enqueueBlockingOperation_(run) {
  1526.     this.destroyer_.ensureNotDestroyed();
  1528.     /** @type {!Array.<!shaka.util.PublicPromise>} */
  1529.     const allWaiters = [];
  1531.     // Enqueue a 'wait' operation onto each queue.
  1532.     // This operation signals its readiness when it starts.
  1533.     // When all wait operations are ready, the real operation takes place.
  1534.     for (const contentType in this.sourceBuffers_) {
  1535.       const ready = new shaka.util.PublicPromise();
  1536.       const operation = {
  1537.         start: () => ready.resolve(),
  1538.         p: ready,
  1539.       };
  1541.       this.queues_[contentType].push(operation);
  1542.       allWaiters.push(ready);
  1544.       if (this.queues_[contentType].length == 1) {
  1545.         operation.start();
  1546.       }
  1547.     }
  1549.     // Return a Promise to the real operation, which waits to begin until
  1550.     // there are no other in-progress operations on any SourceBuffers.
  1551.     try {
  1552.       await Promise.all(allWaiters);
  1553.     } catch (error) {
  1554.       // One of the waiters failed, which means we've been destroyed.
  1555.       goog.asserts.assert(
  1556.           this.destroyer_.destroyed(), 'Should be destroyed by now');
  1557.       // We haven't popped from the queue.  Canceled waiters have been removed
  1558.       // by destroy.  What's left now should just be resolved waiters.  In
  1559.       // uncompiled mode, we will maintain good hygiene and make sure the
  1560.       // assert at the end of destroy passes.  In compiled mode, the queues
  1561.       // are wiped in destroy.
  1562.       if (goog.DEBUG) {
  1563.         for (const contentType in this.sourceBuffers_) {
  1564.           if (this.queues_[contentType].length) {
  1565.             goog.asserts.assert(
  1566.                 this.queues_[contentType].length == 1,
  1567.                 'Should be at most one item in queue!');
  1568.             goog.asserts.assert(
  1569.                 allWaiters.includes(this.queues_[contentType][0].p),
  1570.                 'The item in queue should be one of our waiters!');
  1571.             this.queues_[contentType].shift();
  1572.           }
  1573.         }
  1574.       }
  1575.       throw error;
  1576.     }
  1578.     if (goog.DEBUG) {
  1579.       // If we did it correctly, nothing is updating.
  1580.       for (const contentType in this.sourceBuffers_) {
  1581.         goog.asserts.assert(
  1582.             this.sourceBuffers_[contentType].updating == false,
  1583.             'SourceBuffers should not be updating after a blocking op!');
  1584.       }
  1585.     }
  1587.     // Run the real operation, which can be asynchronous.
  1588.     try {
  1589.       await run();
  1590.     } catch (exception) {
  1591.       throw new shaka.util.Error(
  1592.           shaka.util.Error.Severity.CRITICAL,
  1593.           shaka.util.Error.Category.MEDIA,
  1594.           shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  1595.           exception,
  1596.           this.video_.error || 'No error in the media element');
  1597.     } finally {
  1598.       // Unblock the queues.
  1599.       for (const contentType in this.sourceBuffers_) {
  1600.         this.popFromQueue_(contentType);
  1601.       }
  1602.     }
  1603.   }
  1605.   /**
  1606.    * Pop from the front of the queue and start a new operation.
  1607.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1608.    * @private
  1609.    */
  1610.   popFromQueue_(contentType) {
  1611.     // Remove the in-progress operation, which is now complete.
  1612.     this.queues_[contentType].shift();
  1613.     this.startOperation_(contentType);
  1614.   }
  1616.   /**
  1617.    * Starts the next operation in the queue.
  1618.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1619.    * @private
  1620.    */
  1621.   startOperation_(contentType) {
  1622.     // Retrieve the next operation, if any, from the queue and start it.
  1623.     const next = this.queues_[contentType][0];
  1624.     if (next) {
  1625.       try {
  1626.         next.start();
  1627.       } catch (exception) {
  1628.         if (exception.name == 'QuotaExceededError') {
  1629.           next.p.reject(new shaka.util.Error(
  1630.               shaka.util.Error.Severity.CRITICAL,
  1631.               shaka.util.Error.Category.MEDIA,
  1632.               shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR,
  1633.               contentType));
  1634.         } else {
  1635.           next.p.reject(new shaka.util.Error(
  1636.               shaka.util.Error.Severity.CRITICAL,
  1637.               shaka.util.Error.Category.MEDIA,
  1638.               shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  1639.               exception,
  1640.               this.video_.error || 'No error in the media element'));
  1641.         }
  1642.         this.popFromQueue_(contentType);
  1643.       }
  1644.     }
  1645.   }
  1647.   /**
  1648.    * @return {!shaka.extern.TextDisplayer}
  1649.    */
  1650.   getTextDisplayer() {
  1651.     goog.asserts.assert(
  1652.         this.textDisplayer_,
  1653.         'TextDisplayer should only be null when this is destroyed');
  1655.     return this.textDisplayer_;
  1656.   }
  1658.   /**
  1659.    * @param {!shaka.extern.TextDisplayer} textDisplayer
  1660.    */
  1661.   setTextDisplayer(textDisplayer) {
  1662.     const oldTextDisplayer = this.textDisplayer_;
  1663.     this.textDisplayer_ = textDisplayer;
  1664.     if (oldTextDisplayer) {
  1665.       textDisplayer.setTextVisibility(oldTextDisplayer.isTextVisible());
  1666.       oldTextDisplayer.destroy();
  1667.     }
  1668.     if (this.textEngine_) {
  1669.       this.textEngine_.setDisplayer(textDisplayer);
  1670.     }
  1671.   }
  1673.   /**
  1674.    * @param {boolean} segmentRelativeVttTiming
  1675.    */
  1676.   setSegmentRelativeVttTiming(segmentRelativeVttTiming) {
  1677.     this.segmentRelativeVttTiming_ = segmentRelativeVttTiming;
  1678.   }
  1680.   /**
  1681.    * Apply platform-specific transformations to this segment to work around
  1682.    * issues in the platform.
  1683.    *
  1684.    * @param {!BufferSource} segment
  1685.    * @param {?number} startTime
  1686.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1687.    * @return {!BufferSource}
  1688.    * @private
  1689.    */
  1690.   workAroundBrokenPlatforms_(segment, startTime, contentType) {
  1691.     const isInitSegment = startTime == null;
  1692.     const encryptionExpected = this.expectedEncryption_[contentType];
  1694.     // If:
  1695.     //   1. the configuration tells to insert fake encryption,
  1696.     //   2. and this is an init segment,
  1697.     //   3. and encryption is expected,
  1698.     //   4. and the platform requires encryption in all init segments,
  1699.     //   5. and the content is MP4 (mimeType == "video/mp4" or "audio/mp4"),
  1700.     // then insert fake encryption metadata for init segments that lack it.
  1701.     // The MP4 requirement is because we can currently only do this
  1702.     // transformation on MP4 containers.
  1703.     // See: https://github.com/shaka-project/shaka-player/issues/2759
  1704.     if (this.config_.insertFakeEncryptionInInit &&
  1705.         isInitSegment &&
  1706.         encryptionExpected &&
  1707.         shaka.util.Platform.requiresEncryptionInfoInAllInitSegments() &&
  1708.         shaka.util.MimeUtils.getContainerType(
  1709.             this.sourceBufferTypes_[contentType]) == 'mp4') {
  1710.       shaka.log.debug('Forcing fake encryption information in init segment.');
  1711.       segment = shaka.media.ContentWorkarounds.fakeEncryption(segment);
  1712.     }
  1714.     return segment;
  1715.   }
  1717.   /**
  1718.    * Prepare the SourceBuffer to parse a potentially new type or codec.
  1719.    *
  1720.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1721.    * @param {string} mimeType
  1722.    * @param {?shaka.extern.Transmuxer} transmuxer
  1723.    * @private
  1724.    */
  1725.   change_(contentType, mimeType, transmuxer) {
  1726.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1727.     if (contentType === ContentType.TEXT) {
  1728.       shaka.log.debug(`Change not supported for ${contentType}`);
  1729.       return;
  1730.     }
  1731.     shaka.log.debug(
  1732.         `Change Type: ${this.sourceBufferTypes_[contentType]} -> ${mimeType}`);
  1733.     if (shaka.media.Capabilities.isChangeTypeSupported()) {
  1734.       if (this.transmuxers_[contentType]) {
  1735.         this.transmuxers_[contentType].destroy();
  1736.         delete this.transmuxers_[contentType];
  1737.       }
  1738.       if (transmuxer) {
  1739.         this.transmuxers_[contentType] = transmuxer;
  1740.       }
  1741.       const type = this.addExtraFeaturesToMimeType_(mimeType);
  1742.       this.sourceBuffers_[contentType].changeType(type);
  1743.       this.sourceBufferTypes_[contentType] = mimeType;
  1744.     } else {
  1745.       shaka.log.debug('Change Type not supported');
  1746.     }
  1748.     // Fake an 'updateend' event to resolve the operation.
  1749.     this.onUpdateEnd_(contentType);
  1750.   }
  1752.   /**
  1753.    * Enqueue an operation to prepare the SourceBuffer to parse a potentially new
  1754.    * type or codec.
  1755.    *
  1756.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1757.    * @param {string} mimeType
  1758.    * @param {?shaka.extern.Transmuxer} transmuxer
  1759.    * @return {!Promise}
  1760.    */
  1761.   changeType(contentType, mimeType, transmuxer) {
  1762.     return this.enqueueOperation_(
  1763.         contentType,
  1764.         () => this.change_(contentType, mimeType, transmuxer));
  1765.   }
  1767.   /**
  1768.    * Resets the MediaSource and re-adds source buffers due to codec mismatch
  1769.    *
  1770.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  1771.    *               shaka.extern.Stream>} streamsByType
  1772.    * @private
  1773.    */
  1774.   async reset_(streamsByType) {
  1775.     const Functional = shaka.util.Functional;
  1776.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1777.     this.reloadingMediaSource_ = true;
  1778.     this.needSplitMuxedContent_ = false;
  1779.     const currentTime = this.video_.currentTime;
  1781.     // When codec switching if the user is currently paused we don't want
  1782.     // to trigger a play when switching codec.
  1783.     // Playing can also end up in a paused state after a codec switch
  1784.     // so we need to remember the current states.
  1785.     const previousAutoPlayState = this.video_.autoplay;
  1786.     const previousPausedState = this.video_.paused;
  1787.     if (this.playbackHasBegun_) {
  1788.       // Only set autoplay to false if the video playback has already begun.
  1789.       // When a codec switch happens before playback has begun this can cause
  1790.       // autoplay not to work as expected.
  1791.       this.video_.autoplay = false;
  1792.     }
  1794.     try {
  1795.       this.eventManager_.removeAll();
  1797.       const cleanup = [];
  1798.       for (const contentType in this.transmuxers_) {
  1799.         cleanup.push(this.transmuxers_[contentType].destroy());
  1800.       }
  1801.       for (const contentType in this.queues_) {
  1802.         // Make a local copy of the queue and the first item.
  1803.         const q = this.queues_[contentType];
  1804.         const inProgress = q[0];
  1806.         // Drop everything else out of the original queue.
  1807.         this.queues_[contentType] = q.slice(0, 1);
  1809.         // We will wait for this item to complete/fail.
  1810.         if (inProgress) {
  1811.           cleanup.push(inProgress.p.catch(Functional.noop));
  1812.         }
  1814.         // The rest will be rejected silently if possible.
  1815.         for (const item of q.slice(1)) {
  1816.           item.p.reject(shaka.util.Destroyer.destroyedError());
  1817.         }
  1818.       }
  1819.       for (const contentType in this.sourceBuffers_) {
  1820.         const sourceBuffer = this.sourceBuffers_[contentType];
  1821.         try {
  1822.           this.mediaSource_.removeSourceBuffer(sourceBuffer);
  1823.         } catch (e) {}
  1824.       }
  1825.       await Promise.all(cleanup);
  1826.       this.transmuxers_ = {};
  1827.       this.sourceBuffers_ = {};
  1829.       const previousDuration = this.mediaSource_.duration;
  1830.       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
  1831.       this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
  1832.       await this.mediaSourceOpen_;
  1833.       if (!isNaN(previousDuration) && previousDuration) {
  1834.         this.mediaSource_.duration = previousDuration;
  1835.       } else if (!isNaN(this.lastDuration_) && this.lastDuration_) {
  1836.         this.mediaSource_.duration = this.lastDuration_;
  1837.       }
  1839.       const sourceBufferAdded = new shaka.util.PublicPromise();
  1840.       const sourceBuffers =
  1841.         /** @type {EventTarget} */(this.mediaSource_.sourceBuffers);
  1843.       const totalOfBuffers = streamsByType.size;
  1844.       let numberOfSourceBufferAdded = 0;
  1845.       const onSourceBufferAdded = () => {
  1846.         numberOfSourceBufferAdded++;
  1847.         if (numberOfSourceBufferAdded === totalOfBuffers) {
  1848.           sourceBufferAdded.resolve();
  1849.           this.eventManager_.unlisten(sourceBuffers, 'addsourcebuffer',
  1850.               onSourceBufferAdded);
  1851.         }
  1852.       };
  1854.       this.eventManager_.listen(sourceBuffers, 'addsourcebuffer',
  1855.           onSourceBufferAdded);
  1857.       for (const contentType of streamsByType.keys()) {
  1858.         const stream = streamsByType.get(contentType);
  1859.         // eslint-disable-next-line no-await-in-loop
  1860.         await this.initSourceBuffer_(contentType, stream, stream.codecs);
  1861.         if (this.needSplitMuxedContent_) {
  1862.           this.queues_[ContentType.AUDIO] = [];
  1863.           this.queues_[ContentType.VIDEO] = [];
  1864.         } else {
  1865.           this.queues_[contentType] = [];
  1866.         }
  1867.       }
  1869.       // Fake a seek to catchup the playhead.
  1870.       this.video_.currentTime = currentTime;
  1872.       await sourceBufferAdded;
  1873.     } finally {
  1874.       this.reloadingMediaSource_ = false;
  1876.       this.destroyer_.ensureNotDestroyed();
  1878.       this.eventManager_.listenOnce(this.video_, 'canplaythrough', () => {
  1879.         // Don't use ensureNotDestroyed() from this event listener, because
  1880.         // that results in an uncaught exception.  Instead, just check the
  1881.         // flag.
  1882.         if (this.destroyer_.destroyed()) {
  1883.           return;
  1884.         }
  1886.         this.video_.autoplay = previousAutoPlayState;
  1887.         if (!previousPausedState) {
  1888.           this.video_.play();
  1889.         }
  1890.       });
  1891.     }
  1892.   }
  1894.   /**
  1895.    * Resets the Media Source
  1896.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  1897.    *               shaka.extern.Stream>} streamsByType
  1898.    * @return {!Promise}
  1899.    */
  1900.   reset(streamsByType) {
  1901.     return this.enqueueBlockingOperation_(
  1902.         () => this.reset_(streamsByType));
  1903.   }
  1905.   /**
  1906.    * Codec switch if necessary, this will not resolve until the codec
  1907.    * switch is over.
  1908.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1909.    * @param {string} mimeType
  1910.    * @param {string} codecs
  1911.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  1912.    *               shaka.extern.Stream>} streamsByType
  1913.    * @return {!Promise.<boolean>} true if there was a codec switch,
  1914.    *                              false otherwise.
  1915.    * @private
  1916.    */
  1917.   async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
  1918.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1919.     if (contentType == ContentType.TEXT) {
  1920.       return false;
  1921.     }
  1922.     const MimeUtils = shaka.util.MimeUtils;
  1923.     const currentCodec = MimeUtils.getCodecBase(
  1924.         MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
  1925.     const currentBasicType = MimeUtils.getBasicType(
  1926.         this.sourceBufferTypes_[contentType]);
  1928.     /** @type {?shaka.extern.Transmuxer} */
  1929.     let transmuxer;
  1930.     let transmuxerMuxed = false;
  1931.     let newMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
  1932.     let needTransmux = this.config_.forceTransmux;
  1933.     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
  1934.         (!this.sequenceMode_ &&
  1935.         shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
  1936.       needTransmux = true;
  1937.     }
  1938.     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
  1939.     if (needTransmux) {
  1940.       const newMimeTypeWithAllCodecs =
  1941.           shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codecs);
  1942.       const transmuxerPlugin =
  1943.           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
  1944.       if (transmuxerPlugin) {
  1945.         transmuxer = transmuxerPlugin();
  1946.         const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1947.             ContentType.AUDIO, (codecs || '').split(','));
  1948.         const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1949.             ContentType.VIDEO, (codecs || '').split(','));
  1950.         if (audioCodec && videoCodec) {
  1951.           transmuxerMuxed = true;
  1952.           let codec = videoCodec;
  1953.           if (contentType == ContentType.AUDIO) {
  1954.             codec = audioCodec;
  1955.           }
  1956.           newMimeType = transmuxer.convertCodecs(contentType,
  1957.               shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codec));
  1958.         } else {
  1959.           newMimeType =
  1960.               transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
  1961.         }
  1962.       }
  1963.     }
  1965.     const newCodec = MimeUtils.getCodecBase(
  1966.         MimeUtils.getCodecs(newMimeType));
  1967.     const newBasicType = MimeUtils.getBasicType(newMimeType);
  1969.     // Current/new codecs base and basic type match then no need to switch
  1970.     if (currentCodec === newCodec && currentBasicType === newBasicType) {
  1971.       return false;
  1972.     }
  1974.     let allowChangeType = true;
  1975.     if (this.needSplitMuxedContent_ || (transmuxerMuxed &&
  1976.         transmuxer && !this.transmuxers_[contentType])) {
  1977.       allowChangeType = false;
  1978.     }
  1980.     if (allowChangeType && this.config_.codecSwitchingStrategy ===
  1981.         shaka.config.CodecSwitchingStrategy.SMOOTH &&
  1982.           shaka.media.Capabilities.isChangeTypeSupported()) {
  1983.       await this.changeType(contentType, newMimeType, transmuxer);
  1984.     } else {
  1985.       if (transmuxer) {
  1986.         transmuxer.destroy();
  1987.       }
  1988.       await this.reset(streamsByType);
  1989.     }
  1990.     return true;
  1991.   }
  1993.   /**
  1994.    * Returns true if it's necessary codec switch to load the new stream.
  1995.    *
  1996.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1997.    * @param {shaka.extern.Stream} stream
  1998.    * @param {string} refMimeType
  1999.    * @param {string} refCodecs
  2000.    * @return {boolean}
  2001.    * @private
  2002.    */
  2003.   isCodecSwitchNecessary_(contentType, stream, refMimeType, refCodecs) {
  2004.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  2005.       return false;
  2006.     }
  2007.     const MimeUtils = shaka.util.MimeUtils;
  2008.     const currentCodec = MimeUtils.getCodecBase(
  2009.         MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
  2010.     const currentBasicType = MimeUtils.getBasicType(
  2011.         this.sourceBufferTypes_[contentType]);
  2013.     let newMimeType = shaka.util.MimeUtils.getFullType(refMimeType, refCodecs);
  2014.     let needTransmux = this.config_.forceTransmux;
  2015.     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
  2016.         (!this.sequenceMode_ &&
  2017.         shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
  2018.       needTransmux = true;
  2019.     }
  2020.     const newMimeTypeWithAllCodecs =
  2021.         shaka.util.MimeUtils.getFullTypeWithAllCodecs(
  2022.             refMimeType, refCodecs);
  2023.     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
  2024.     if (needTransmux) {
  2025.       const transmuxerPlugin =
  2026.           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
  2027.       if (transmuxerPlugin) {
  2028.         const transmuxer = transmuxerPlugin();
  2029.         newMimeType =
  2030.             transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
  2031.         transmuxer.destroy();
  2032.       }
  2033.     }
  2035.     const newCodec = MimeUtils.getCodecBase(
  2036.         MimeUtils.getCodecs(newMimeType));
  2037.     const newBasicType = MimeUtils.getBasicType(newMimeType);
  2039.     return currentCodec !== newCodec || currentBasicType !== newBasicType;
  2040.   }
  2042.   /**
  2043.    * Returns true if it's necessary reset the media source to load the
  2044.    * new stream.
  2045.    *
  2046.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2047.    * @param {shaka.extern.Stream} stream
  2048.    * @param {string} mimeType
  2049.    * @param {string} codecs
  2050.    * @return {boolean}
  2051.    */
  2052.   isResetMediaSourceNecessary(contentType, stream, mimeType, codecs) {
  2053.     if (!this.isCodecSwitchNecessary_(contentType, stream, mimeType, codecs)) {
  2054.       return false;
  2055.     }
  2057.     return this.config_.codecSwitchingStrategy !==
  2058.         shaka.config.CodecSwitchingStrategy.SMOOTH ||
  2059.         !shaka.media.Capabilities.isChangeTypeSupported() ||
  2060.         this.needSplitMuxedContent_;
  2061.   }
  2063.   /**
  2064.    * Update LCEVC Decoder object when ready for LCEVC Decode.
  2065.    * @param {?shaka.lcevc.Dec} lcevcDec
  2066.    */
  2067.   updateLcevcDec(lcevcDec) {
  2068.     this.lcevcDec_ = lcevcDec;
  2069.   }
  2071.   /**
  2072.    * @param {string} mimeType
  2073.    * @return {string}
  2074.    * @private
  2075.    */
  2076.   addExtraFeaturesToMimeType_(mimeType) {
  2077.     const extraFeatures = this.config_.addExtraFeaturesToSourceBuffer(mimeType);
  2078.     const extendedType = mimeType + extraFeatures;
  2079.     shaka.log.debug('Using full mime type', extendedType);
  2081.     return extendedType;
  2082.   }
  2083. };
  2086. /**
  2087.  * Internal reference to window.URL.createObjectURL function to avoid
  2088.  * compatibility issues with other libraries and frameworks such as React
  2089.  * Native. For use in unit tests only, not meant for external use.
  2090.  *
  2091.  * @type {function(?):string}
  2092.  */
  2093. shaka.media.MediaSourceEngine.createObjectURL = window.URL.createObjectURL;
  2096. /**
  2097.  * @typedef {{
  2098.  *   start: function(),
  2099.  *   p: !shaka.util.PublicPromise
  2100.  * }}
  2101.  *
  2102.  * @summary An operation in queue.
  2103.  * @property {function()} start
  2104.  *   The function which starts the operation.
  2105.  * @property {!shaka.util.PublicPromise} p
  2106.  *   The PublicPromise which is associated with this operation.
  2107.  */
  2108. shaka.media.MediaSourceEngine.Operation;
  2111. /**
  2112.  * @enum {string}
  2113.  * @private
  2114.  */
  2115. shaka.media.MediaSourceEngine.SourceBufferMode_ = {
  2116.   SEQUENCE: 'sequence',
  2117.   SEGMENTS: 'segments',
  2118. };