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 {!shaka.media.MediaSourceEngine.PlayerInterface} playerInterface
  57.    *   Interface for common player methods.
  58.    * @param {?shaka.lcevc.Dec} [lcevcDec] Optional -  LCEVC Decoder Object
  59.    */
  60.   constructor(video, textDisplayer, playerInterface, lcevcDec) {
  61.     /** @private {HTMLMediaElement} */
  62.     this.video_ = video;
  64.     /** @private {?shaka.media.MediaSourceEngine.PlayerInterface} */
  65.     this.playerInterface_ = playerInterface;
  67.     /** @private {?shaka.extern.MediaSourceConfiguration} */
  68.     this.config_ = null;
  70.     /** @private {shaka.extern.TextDisplayer} */
  71.     this.textDisplayer_ = textDisplayer;
  73.     /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  74.                            SourceBuffer>} */
  75.     this.sourceBuffers_ = {};
  77.     /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  78.                            string>} */
  79.     this.sourceBufferTypes_ = {};
  82.     /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  83.                            boolean>} */
  84.     this.expectedEncryption_ = {};
  86.     /** @private {shaka.text.TextEngine} */
  87.     this.textEngine_ = null;
  89.     /** @private {boolean} */
  90.     this.segmentRelativeVttTiming_ = false;
  92.     /** @private {?shaka.lcevc.Dec} */
  93.     this.lcevcDec_ = lcevcDec || null;
  95.     /**
  96.      * @private {!Object.<string,
  97.      *                    !Array.<shaka.media.MediaSourceEngine.Operation>>}
  98.      */
  99.     this.queues_ = {};
  101.     /** @private {shaka.util.EventManager} */
  102.     this.eventManager_ = new shaka.util.EventManager();
  104.     /** @private {!Object.<string, !shaka.extern.Transmuxer>} */
  105.     this.transmuxers_ = {};
  107.     /** @private {?shaka.media.IClosedCaptionParser} */
  108.     this.captionParser_ = null;
  110.     /** @private {!shaka.util.PublicPromise} */
  111.     this.mediaSourceOpen_ = new shaka.util.PublicPromise();
  113.     /** @private {string} */
  114.     this.url_ = '';
  116.     /** @private {boolean} */
  117.     this.playbackHasBegun_ = false;
  119.     /** @private {MediaSource} */
  120.     this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
  122.     /** @private {boolean} */
  123.     this.reloadingMediaSource_ = false;
  125.     /** @type {!shaka.util.Destroyer} */
  126.     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
  128.     /** @private {boolean} */
  129.     this.sequenceMode_ = false;
  131.     /** @private {string} */
  132.     this.manifestType_ = shaka.media.ManifestParser.UNKNOWN;
  134.     /** @private {boolean} */
  135.     this.ignoreManifestTimestampsInSegmentsMode_ = false;
  137.     /** @private {boolean} */
  138.     this.attemptTimestampOffsetCalculation_ = false;
  140.     /** @private {!shaka.util.PublicPromise.<number>} */
  141.     this.textSequenceModeOffset_ = new shaka.util.PublicPromise();
  143.     /** @private {boolean} */
  144.     this.needSplitMuxedContent_ = false;
  146.     /** @private {boolean} */
  147.     this.streamingAllowed_ = true;
  149.     /** @private {?number} */
  150.     this.lastDuration_ = null;
  152.     /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  153.                            !shaka.util.TsParser>} */
  154.     this.tsParsers_ = {};
  156.     /** @private {?number} */
  157.     this.firstVideoTimestamp_ = null;
  159.     /** @private {?number} */
  160.     this.firstVideoReferenceStartTime_ = null;
  162.     /** @private {?number} */
  163.     this.firstAudioTimestamp_ = null;
  165.     /** @private {?number} */
  166.     this.firstAudioReferenceStartTime_ = null;
  168.     /** @private {!shaka.util.PublicPromise.<number>} */
  169.     this.audioCompensation_ = new shaka.util.PublicPromise();
  170.   }
  172.   /**
  173.    * Create a MediaSource object, attach it to the video element, and return it.
  174.    * Resolves the given promise when the MediaSource is ready.
  175.    *
  176.    * Replaced by unit tests.
  177.    *
  178.    * @param {!shaka.util.PublicPromise} p
  179.    * @return {!MediaSource}
  180.    */
  181.   createMediaSource(p) {
  182.     this.streamingAllowed_ = true;
  184.     /** @type {!MediaSource} */
  185.     let mediaSource;
  187.     if (window.ManagedMediaSource) {
  188.       this.video_.disableRemotePlayback = true;
  190.       mediaSource = new ManagedMediaSource();
  192.       this.eventManager_.listen(
  193.           mediaSource, 'startstreaming', () => {
  194.             shaka.log.info('MMS startstreaming');
  195.             this.streamingAllowed_ = true;
  196.           });
  198.       this.eventManager_.listen(
  199.           mediaSource, 'endstreaming', () => {
  200.             shaka.log.info('MMS endstreaming');
  201.             this.streamingAllowed_ = false;
  202.           });
  203.     } else {
  204.       mediaSource = new MediaSource();
  205.     }
  207.     // Set up MediaSource on the video element.
  208.     this.eventManager_.listenOnce(
  209.         mediaSource, 'sourceopen', () => this.onSourceOpen_(p));
  211.     // Correctly set when playback has begun.
  212.     this.eventManager_.listenOnce(this.video_, 'playing', () => {
  213.       this.playbackHasBegun_ = true;
  214.     });
  216.     // Store the object URL for releasing it later.
  217.     this.url_ = shaka.media.MediaSourceEngine.createObjectURL(mediaSource);
  219.     this.video_.src = this.url_;
  221.     return mediaSource;
  222.   }
  224.   /**
  225.    * @param {shaka.util.PublicPromise} p
  226.    * @private
  227.    */
  228.   onSourceOpen_(p) {
  229.     goog.asserts.assert(this.url_, 'Must have object URL');
  231.     // Release the object URL that was previously created, to prevent memory
  232.     // leak.
  233.     // createObjectURL creates a strong reference to the MediaSource object
  234.     // inside the browser.  Setting the src of the video then creates another
  235.     // reference within the video element.  revokeObjectURL will remove the
  236.     // strong reference to the MediaSource object, and allow it to be
  237.     // garbage-collected later.
  238.     URL.revokeObjectURL(this.url_);
  239.     p.resolve();
  240.   }
  242.   /**
  243.    * Checks if a certain type is supported.
  244.    *
  245.    * @param {shaka.extern.Stream} stream
  246.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  247.    * @return {!Promise.<boolean>}
  248.    */
  249.   static async isStreamSupported(stream, contentType) {
  250.     if (stream.createSegmentIndex) {
  251.       await stream.createSegmentIndex();
  252.     }
  253.     if (!stream.segmentIndex) {
  254.       return false;
  255.     }
  256.     if (stream.segmentIndex.isEmpty()) {
  257.       return true;
  258.     }
  259.     const MimeUtils = shaka.util.MimeUtils;
  260.     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
  261.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  262.     const StreamUtils = shaka.util.StreamUtils;
  263.     const seenCombos = new Set();
  264.     // Check each combination of mimeType and codecs within the segment index.
  265.     // Unfortunately we cannot use fullMimeTypes, as we ALSO need to check the
  266.     // getFullTypeWithAllCodecs (for the sake of the transmuxer) and we have no
  267.     // way of going from a full mimeType to a full mimeType with all codecs.
  268.     // As this function is only called in debug mode, a little inefficiency is
  269.     // acceptable.
  270.     for (const ref of stream.segmentIndex) {
  271.       const mimeType = ref.mimeType || stream.mimeType || '';
  272.       let codecs = ref.codecs || stream.codecs || '';
  273.       // Optimization for the case where the codecs and mimetype of the stream
  274.       // match the reference.
  275.       if (mimeType == stream.mimeType && codecs == stream.codecs) {
  276.         continue;
  277.       }
  278.       // Don't check the same combination of mimetype + codecs twice.
  279.       const combo = mimeType + ':' + codecs;
  280.       if (seenCombos.has(combo)) {
  281.         continue;
  282.       }
  283.       seenCombos.add(combo);
  284.       if (contentType == ContentType.TEXT) {
  285.         const fullMimeType = MimeUtils.getFullType(mimeType, codecs);
  286.         if (!shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
  287.           return false;
  288.         }
  289.       } else {
  290.         if (contentType == ContentType.VIDEO) {
  291.           codecs = StreamUtils.getCorrectVideoCodecs(codecs);
  292.         } else if (contentType == ContentType.AUDIO) {
  293.           codecs = StreamUtils.getCorrectAudioCodecs(codecs, mimeType);
  294.         }
  295.         const extendedMimeType = MimeUtils.getExtendedType(
  296.             stream, mimeType, codecs);
  297.         const fullMimeType = MimeUtils.getFullTypeWithAllCodecs(
  298.             mimeType, codecs);
  299.         if (!shaka.media.Capabilities.isTypeSupported(extendedMimeType) &&
  300.             !TransmuxerEngine.isSupported(fullMimeType, stream.type)) {
  301.           return false;
  302.         }
  303.       }
  304.     }
  305.     return true;
  306.   }
  308.   /**
  309.    * Returns a map of MediaSource support for well-known types.
  310.    *
  311.    * @return {!Object.<string, boolean>}
  312.    */
  313.   static probeSupport() {
  314.     const testMimeTypes = [
  315.       // MP4 types
  316.       'video/mp4; codecs="avc1.42E01E"',
  317.       'video/mp4; codecs="avc3.42E01E"',
  318.       'video/mp4; codecs="hev1.1.6.L93.90"',
  319.       'video/mp4; codecs="hvc1.1.6.L93.90"',
  320.       'video/mp4; codecs="hev1.2.4.L153.B0"; eotf="smpte2084"',  // HDR HEVC
  321.       'video/mp4; codecs="hvc1.2.4.L153.B0"; eotf="smpte2084"',  // HDR HEVC
  322.       'video/mp4; codecs="vp9"',
  323.       'video/mp4; codecs="vp09.00.10.08"',
  324.       'video/mp4; codecs="av01.0.01M.08"',
  325.       'video/mp4; codecs="dvh1.20.01"',
  326.       'audio/mp4; codecs="mp4a.40.2"',
  327.       'audio/mp4; codecs="ac-3"',
  328.       'audio/mp4; codecs="ec-3"',
  329.       'audio/mp4; codecs="ac-4.02.01.01"',
  330.       'audio/mp4; codecs="opus"',
  331.       'audio/mp4; codecs="flac"',
  332.       'audio/mp4; codecs="dtsc"', // DTS Digital Surround
  333.       'audio/mp4; codecs="dtse"', // DTS Express
  334.       'audio/mp4; codecs="dtsx"', // DTS:X
  335.       // WebM types
  336.       'video/webm; codecs="vp8"',
  337.       'video/webm; codecs="vp9"',
  338.       'video/webm; codecs="vp09.00.10.08"',
  339.       'audio/webm; codecs="vorbis"',
  340.       'audio/webm; codecs="opus"',
  341.       // MPEG2 TS types (video/ is also used for audio: https://bit.ly/TsMse)
  342.       'video/mp2t; codecs="avc1.42E01E"',
  343.       'video/mp2t; codecs="avc3.42E01E"',
  344.       'video/mp2t; codecs="hvc1.1.6.L93.90"',
  345.       'video/mp2t; codecs="mp4a.40.2"',
  346.       'video/mp2t; codecs="ac-3"',
  347.       'video/mp2t; codecs="ec-3"',
  348.       // WebVTT types
  349.       'text/vtt',
  350.       'application/mp4; codecs="wvtt"',
  351.       // TTML types
  352.       'application/ttml+xml',
  353.       'application/mp4; codecs="stpp"',
  354.       // Containerless types
  355.       ...shaka.util.MimeUtils.RAW_FORMATS,
  356.     ];
  358.     const support = {};
  359.     for (const type of testMimeTypes) {
  360.       if (shaka.text.TextEngine.isTypeSupported(type)) {
  361.         support[type] = true;
  362.       } else if (shaka.util.Platform.supportsMediaSource()) {
  363.         support[type] = shaka.media.Capabilities.isTypeSupported(type) ||
  364.                         shaka.transmuxer.TransmuxerEngine.isSupported(type);
  365.       } else {
  366.         support[type] = shaka.util.Platform.supportsMediaType(type);
  367.       }
  369.       const basicType = type.split(';')[0];
  370.       support[basicType] = support[basicType] || support[type];
  371.     }
  373.     return support;
  374.   }
  376.   /** @override */
  377.   destroy() {
  378.     return this.destroyer_.destroy();
  379.   }
  381.   /** @private */
  382.   async doDestroy_() {
  383.     const Functional = shaka.util.Functional;
  385.     const cleanup = [];
  387.     for (const contentType in this.queues_) {
  388.       // Make a local copy of the queue and the first item.
  389.       const q = this.queues_[contentType];
  390.       const inProgress = q[0];
  392.       // Drop everything else out of the original queue.
  393.       this.queues_[contentType] = q.slice(0, 1);
  395.       // We will wait for this item to complete/fail.
  396.       if (inProgress) {
  397.         cleanup.push(inProgress.p.catch(Functional.noop));
  398.       }
  400.       // The rest will be rejected silently if possible.
  401.       for (const item of q.slice(1)) {
  402.         item.p.reject(shaka.util.Destroyer.destroyedError());
  403.       }
  404.     }
  406.     if (this.textEngine_) {
  407.       cleanup.push(this.textEngine_.destroy());
  408.     }
  409.     if (this.textDisplayer_) {
  410.       cleanup.push(this.textDisplayer_.destroy());
  411.     }
  413.     for (const contentType in this.transmuxers_) {
  414.       cleanup.push(this.transmuxers_[contentType].destroy());
  415.     }
  418.     await Promise.all(cleanup);
  419.     if (this.eventManager_) {
  420.       this.eventManager_.release();
  421.       this.eventManager_ = null;
  422.     }
  424.     if (this.video_) {
  425.       // "unload" the video element.
  426.       this.video_.removeAttribute('src');
  427.       this.video_.load();
  428.       this.video_ = null;
  429.     }
  431.     this.config_ = null;
  432.     this.mediaSource_ = null;
  433.     this.textEngine_ = null;
  434.     this.textDisplayer_ = null;
  435.     this.sourceBuffers_ = {};
  436.     this.transmuxers_ = {};
  437.     this.captionParser_ = null;
  438.     if (goog.DEBUG) {
  439.       for (const contentType in this.queues_) {
  440.         goog.asserts.assert(
  441.             this.queues_[contentType].length == 0,
  442.             contentType + ' queue should be empty after destroy!');
  443.       }
  444.     }
  445.     this.queues_ = {};
  447.     // This object is owned by Player
  448.     this.lcevcDec_ = null;
  450.     this.tsParsers_ = {};
  451.     this.playerInterface_ = null;
  452.   }
  454.   /**
  455.    * @return {!Promise} Resolved when MediaSource is open and attached to the
  456.    *   media element.  This process is actually initiated by the constructor.
  457.    */
  458.   open() {
  459.     return this.mediaSourceOpen_;
  460.   }
  462.   /**
  463.    * Initialize MediaSourceEngine.
  464.    *
  465.    * Note that it is not valid to call this multiple times, except to add or
  466.    * reinitialize text streams.
  467.    *
  468.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  469.    *               shaka.extern.Stream>} streamsByType
  470.    *   A map of content types to streams.  All streams must be supported
  471.    *   according to MediaSourceEngine.isStreamSupported.
  472.    * @param {boolean=} sequenceMode
  473.    *   If true, the media segments are appended to the SourceBuffer in strict
  474.    *   sequence.
  475.    * @param {string=} manifestType
  476.    *   Indicates the type of the manifest.
  477.    * @param {boolean=} ignoreManifestTimestampsInSegmentsMode
  478.    *   If true, don't adjust the timestamp offset to account for manifest
  479.    *   segment durations being out of sync with segment durations. In other
  480.    *   words, assume that there are no gaps in the segments when appending
  481.    *   to the SourceBuffer, even if the manifest and segment times disagree.
  482.    *   Indicates if the manifest has text streams.
  483.    *
  484.    * @return {!Promise}
  485.    */
  486.   async init(streamsByType, sequenceMode=false,
  487.       manifestType=shaka.media.ManifestParser.UNKNOWN,
  488.       ignoreManifestTimestampsInSegmentsMode=false) {
  489.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  491.     await this.mediaSourceOpen_;
  492.     if (this.ended() || this.closed()) {
  493.       shaka.log.alwaysError('Expected MediaSource to be open during init(); ' +
  494.           'reopening the media source.');
  495.       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
  496.       this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
  497.       await this.mediaSourceOpen_;
  498.     }
  500.     this.sequenceMode_ = sequenceMode;
  501.     this.manifestType_ = manifestType;
  502.     this.ignoreManifestTimestampsInSegmentsMode_ =
  503.       ignoreManifestTimestampsInSegmentsMode;
  505.     this.attemptTimestampOffsetCalculation_ = !this.sequenceMode_ &&
  506.         this.manifestType_ == shaka.media.ManifestParser.HLS &&
  507.         !this.ignoreManifestTimestampsInSegmentsMode_;
  509.     this.tsParsers_ = {};
  510.     this.firstVideoTimestamp_ = null;
  511.     this.firstVideoReferenceStartTime_ = null;
  512.     this.firstAudioTimestamp_ = null;
  513.     this.firstAudioReferenceStartTime_ = null;
  514.     this.audioCompensation_ = new shaka.util.PublicPromise();
  516.     for (const contentType of streamsByType.keys()) {
  517.       const stream = streamsByType.get(contentType);
  518.       // eslint-disable-next-line no-await-in-loop
  519.       await this.initSourceBuffer_(contentType, stream, stream.codecs);
  520.       if (this.needSplitMuxedContent_) {
  521.         this.queues_[ContentType.AUDIO] = [];
  522.         this.queues_[ContentType.VIDEO] = [];
  523.       } else {
  524.         this.queues_[contentType] = [];
  525.       }
  526.     }
  527.   }
  529.   /**
  530.    * Initialize a specific SourceBuffer.
  531.    *
  532.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  533.    * @param {shaka.extern.Stream} stream
  534.    * @param {string} codecs
  535.    * @return {!Promise}
  536.    * @private
  537.    */
  538.   async initSourceBuffer_(contentType, stream, codecs) {
  539.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  541.     goog.asserts.assert(
  542.         await shaka.media.MediaSourceEngine.isStreamSupported(
  543.             stream, contentType),
  544.         'Type negotiation should happen before MediaSourceEngine.init!');
  546.     let mimeType = shaka.util.MimeUtils.getFullType(
  547.         stream.mimeType, codecs);
  548.     if (contentType == ContentType.TEXT) {
  549.       this.reinitText(mimeType, this.sequenceMode_, stream.external);
  550.     } else {
  551.       let needTransmux = this.config_.forceTransmux;
  552.       if (!shaka.media.Capabilities.isTypeSupported(mimeType) ||
  553.           (!this.sequenceMode_ &&
  554.           shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType))) {
  555.         needTransmux = true;
  556.       }
  557.       const mimeTypeWithAllCodecs =
  558.           shaka.util.MimeUtils.getFullTypeWithAllCodecs(
  559.               stream.mimeType, codecs);
  560.       if (needTransmux) {
  561.         const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  562.             ContentType.AUDIO, (codecs || '').split(','));
  563.         const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  564.             ContentType.VIDEO, (codecs || '').split(','));
  565.         if (audioCodec && videoCodec) {
  566.           this.needSplitMuxedContent_ = true;
  567.           await this.initSourceBuffer_(ContentType.AUDIO, stream, audioCodec);
  568.           await this.initSourceBuffer_(ContentType.VIDEO, stream, videoCodec);
  569.           return;
  570.         }
  571.         const transmuxerPlugin = shaka.transmuxer.TransmuxerEngine
  572.             .findTransmuxer(mimeTypeWithAllCodecs);
  573.         if (transmuxerPlugin) {
  574.           const transmuxer = transmuxerPlugin();
  575.           this.transmuxers_[contentType] = transmuxer;
  576.           mimeType =
  577.               transmuxer.convertCodecs(contentType, mimeTypeWithAllCodecs);
  578.         }
  579.       }
  580.       const type = this.addExtraFeaturesToMimeType_(mimeType);
  582.       this.destroyer_.ensureNotDestroyed();
  584.       let sourceBuffer;
  586.       try {
  587.         sourceBuffer = this.mediaSource_.addSourceBuffer(type);
  588.       } catch (exception) {
  589.         throw new shaka.util.Error(
  590.             shaka.util.Error.Severity.CRITICAL,
  591.             shaka.util.Error.Category.MEDIA,
  592.             shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  593.             exception,
  594.             'The mediaSource_ status was ' + this.mediaSource_.readyState +
  595.             ' expected \'open\'',
  596.             null);
  597.       }
  599.       if (this.sequenceMode_) {
  600.         sourceBuffer.mode =
  601.             shaka.media.MediaSourceEngine.SourceBufferMode_.SEQUENCE;
  602.       }
  604.       this.eventManager_.listen(
  605.           sourceBuffer, 'error',
  606.           () => this.onError_(contentType));
  607.       this.eventManager_.listen(
  608.           sourceBuffer, 'updateend',
  609.           () => this.onUpdateEnd_(contentType));
  610.       this.sourceBuffers_[contentType] = sourceBuffer;
  611.       this.sourceBufferTypes_[contentType] = mimeType;
  612.       this.expectedEncryption_[contentType] = !!stream.drmInfos.length;
  613.     }
  614.   }
  616.   /**
  617.    * Called by the Player to provide an updated configuration any time it
  618.    * changes. Must be called at least once before init().
  619.    *
  620.    * @param {shaka.extern.MediaSourceConfiguration} config
  621.    */
  622.   configure(config) {
  623.     this.config_ = config;
  624.     if (this.textEngine_) {
  625.       this.textEngine_.setModifyCueCallback(config.modifyCueCallback);
  626.     }
  627.   }
  629.   /**
  630.    * Indicate if the streaming is allowed by MediaSourceEngine.
  631.    * If we using MediaSource we allways returns true.
  632.    *
  633.    * @return {boolean}
  634.    */
  635.   isStreamingAllowed() {
  636.     return this.streamingAllowed_;
  637.   }
  639.   /**
  640.    * Reinitialize the TextEngine for a new text type.
  641.    * @param {string} mimeType
  642.    * @param {boolean} sequenceMode
  643.    * @param {boolean} external
  644.    */
  645.   reinitText(mimeType, sequenceMode, external) {
  646.     if (!this.textEngine_) {
  647.       this.textEngine_ = new shaka.text.TextEngine(this.textDisplayer_);
  648.       if (this.textEngine_) {
  649.         this.textEngine_.setModifyCueCallback(this.config_.modifyCueCallback);
  650.       }
  651.     }
  652.     this.textEngine_.initParser(mimeType, sequenceMode,
  653.         external || this.segmentRelativeVttTiming_, this.manifestType_);
  654.   }
  656.   /**
  657.    * @return {boolean} True if the MediaSource is in an "ended" state, or if the
  658.    *   object has been destroyed.
  659.    */
  660.   ended() {
  661.     if (this.reloadingMediaSource_) {
  662.       return false;
  663.     }
  664.     return this.mediaSource_ ? this.mediaSource_.readyState == 'ended' : true;
  665.   }
  667.   /**
  668.    * @return {boolean} True if the MediaSource is in an "closed" state, or if
  669.    *   the object has been destroyed.
  670.    */
  671.   closed() {
  672.     if (this.reloadingMediaSource_) {
  673.       return false;
  674.     }
  675.     return this.mediaSource_ ? this.mediaSource_.readyState == 'closed' : true;
  676.   }
  678.   /**
  679.    * Gets the first timestamp in buffer for the given content type.
  680.    *
  681.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  682.    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  683.    */
  684.   bufferStart(contentType) {
  685.     if (!Object.keys(this.sourceBuffers_).length) {
  686.       return null;
  687.     }
  688.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  689.     if (contentType == ContentType.TEXT) {
  690.       return this.textEngine_.bufferStart();
  691.     }
  692.     return shaka.media.TimeRangesUtils.bufferStart(
  693.         this.getBuffered_(contentType));
  694.   }
  696.   /**
  697.    * Gets the last timestamp in buffer for the given content type.
  698.    *
  699.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  700.    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  701.    */
  702.   bufferEnd(contentType) {
  703.     if (!Object.keys(this.sourceBuffers_).length) {
  704.       return null;
  705.     }
  706.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  707.     if (contentType == ContentType.TEXT) {
  708.       return this.textEngine_.bufferEnd();
  709.     }
  710.     return shaka.media.TimeRangesUtils.bufferEnd(
  711.         this.getBuffered_(contentType));
  712.   }
  714.   /**
  715.    * Determines if the given time is inside the buffered range of the given
  716.    * content type.
  717.    *
  718.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  719.    * @param {number} time Playhead time
  720.    * @return {boolean}
  721.    */
  722.   isBuffered(contentType, time) {
  723.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  724.     if (contentType == ContentType.TEXT) {
  725.       return this.textEngine_.isBuffered(time);
  726.     } else {
  727.       const buffered = this.getBuffered_(contentType);
  728.       return shaka.media.TimeRangesUtils.isBuffered(buffered, time);
  729.     }
  730.   }
  732.   /**
  733.    * Computes how far ahead of the given timestamp is buffered for the given
  734.    * content type.
  735.    *
  736.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  737.    * @param {number} time
  738.    * @return {number} The amount of time buffered ahead in seconds.
  739.    */
  740.   bufferedAheadOf(contentType, time) {
  741.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  742.     if (contentType == ContentType.TEXT) {
  743.       return this.textEngine_.bufferedAheadOf(time);
  744.     } else {
  745.       const buffered = this.getBuffered_(contentType);
  746.       return shaka.media.TimeRangesUtils.bufferedAheadOf(buffered, time);
  747.     }
  748.   }
  750.   /**
  751.    * Returns info about what is currently buffered.
  752.    * @return {shaka.extern.BufferedInfo}
  753.    */
  754.   getBufferedInfo() {
  755.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  756.     const TimeRangesUtils = shaka.media.TimeRangesUtils;
  758.     const info = {
  759.       total: this.reloadingMediaSource_ ? [] :
  760.         TimeRangesUtils.getBufferedInfo(this.video_.buffered),
  761.       audio:
  762.         TimeRangesUtils.getBufferedInfo(this.getBuffered_(ContentType.AUDIO)),
  763.       video:
  764.         TimeRangesUtils.getBufferedInfo(this.getBuffered_(ContentType.VIDEO)),
  765.       text: [],
  766.     };
  768.     if (this.textEngine_) {
  769.       const start = this.textEngine_.bufferStart();
  770.       const end = this.textEngine_.bufferEnd();
  772.       if (start != null && end != null) {
  773.         info.text.push({start: start, end: end});
  774.       }
  775.     }
  776.     return info;
  777.   }
  779.   /**
  780.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  781.    * @return {TimeRanges} The buffered ranges for the given content type, or
  782.    *   null if the buffered ranges could not be obtained.
  783.    * @private
  784.    */
  785.   getBuffered_(contentType) {
  786.     if (this.reloadingMediaSource_) {
  787.       return null;
  788.     }
  789.     try {
  790.       return this.sourceBuffers_[contentType].buffered;
  791.     } catch (exception) {
  792.       if (contentType in this.sourceBuffers_) {
  793.         // Note: previous MediaSource errors may cause access to |buffered| to
  794.         // throw.
  795.         shaka.log.error('failed to get buffered range for ' + contentType,
  796.             exception);
  797.       }
  798.       return null;
  799.     }
  800.   }
  802.   /**
  803.    * Create a new closed caption parser. This will ONLY be replaced by tests as
  804.    * a way to inject fake closed caption parser instances.
  805.    *
  806.    * @param {string} mimeType
  807.    * @return {!shaka.media.IClosedCaptionParser}
  808.    */
  809.   getCaptionParser(mimeType) {
  810.     return new shaka.media.ClosedCaptionParser(mimeType);
  811.   }
  813.   /**
  814.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  815.    * @param {!BufferSource} data
  816.    * @param {?shaka.media.SegmentReference} reference The segment reference
  817.    *   we are appending, or null for init segments
  818.    * @param {!string} mimeType
  819.    * @return {{timestamp: ?number, metadata: !Array.<shaka.extern.ID3Metadata>}}
  820.    * @private
  821.    */
  822.   getTimestampAndDispatchMetadata_(contentType, data, reference, mimeType) {
  823.     let timestamp = null;
  824.     let metadata = [];
  826.     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
  827.     if (shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType)) {
  828.       const frames = shaka.util.Id3Utils.getID3Frames(uint8ArrayData);
  829.       if (frames.length && reference) {
  830.         const metadataTimestamp = frames.find((frame) => {
  831.           return frame.description ===
  832.               'com.apple.streaming.transportStreamTimestamp';
  833.         });
  834.         if (metadataTimestamp) {
  835.           timestamp = Math.round(metadataTimestamp.data) / 1000;
  836.         }
  837.         /** @private {shaka.extern.ID3Metadata} */
  838.         const id3Metadata = {
  839.           cueTime: reference.startTime,
  840.           data: uint8ArrayData,
  841.           frames: frames,
  842.           dts: reference.startTime,
  843.           pts: reference.startTime,
  844.         };
  845.         this.playerInterface_.onMetadata(
  846.             [id3Metadata], /* offset= */ 0, reference.endTime);
  847.       }
  848.     } else if (mimeType.includes('/mp4') &&
  849.         reference && reference.timestampOffset == 0 &&
  850.         reference.initSegmentReference &&
  851.         reference.initSegmentReference.timescale) {
  852.       const timescale = reference.initSegmentReference.timescale;
  853.       if (!isNaN(timescale)) {
  854.         const Mp4Parser = shaka.util.Mp4Parser;
  855.         let startTime = 0;
  856.         let parsedMedia = false;
  857.         new Mp4Parser()
  858.             .box('moof', Mp4Parser.children)
  859.             .box('traf', Mp4Parser.children)
  860.             .fullBox('tfdt', (box) => {
  861.               goog.asserts.assert(
  862.                   box.version == 0 || box.version == 1,
  863.                   'TFDT version can only be 0 or 1');
  864.               const parsed = shaka.util.Mp4BoxParsers.parseTFDTInaccurate(
  865.                   box.reader, box.version);
  866.               startTime = parsed.baseMediaDecodeTime / timescale;
  867.               parsedMedia = true;
  868.               box.parser.stop();
  869.             }).parse(data, /* partialOkay= */ true);
  870.         if (parsedMedia) {
  871.           timestamp = startTime;
  872.         }
  873.       }
  874.     } else if (!mimeType.includes('/mp4') && !mimeType.includes('/webm') &&
  875.         shaka.util.TsParser.probe(uint8ArrayData)) {
  876.       if (!this.tsParsers_[contentType]) {
  877.         this.tsParsers_[contentType] = new shaka.util.TsParser();
  878.       } else {
  879.         this.tsParsers_[contentType].clearData();
  880.       }
  881.       const tsParser = this.tsParsers_[contentType].parse(uint8ArrayData);
  882.       const startTime = tsParser.getStartTime(contentType);
  883.       if (startTime != null) {
  884.         timestamp = startTime;
  885.       }
  886.       metadata = tsParser.getMetadata();
  887.     }
  888.     return {timestamp, metadata};
  889.   }
  891.   /**
  892.    * Enqueue an operation to append data to the SourceBuffer.
  893.    * Start and end times are needed for TextEngine, but not for MediaSource.
  894.    * Start and end times may be null for initialization segments; if present
  895.    * they are relative to the presentation timeline.
  896.    *
  897.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  898.    * @param {!BufferSource} data
  899.    * @param {?shaka.media.SegmentReference} reference The segment reference
  900.    *   we are appending, or null for init segments
  901.    * @param {shaka.extern.Stream} stream
  902.    * @param {?boolean} hasClosedCaptions True if the buffer contains CEA closed
  903.    *   captions
  904.    * @param {boolean=} seeked True if we just seeked
  905.    * @param {boolean=} adaptation True if we just automatically switched active
  906.    *   variant(s).
  907.    * @param {boolean=} isChunkedData True if we add to the buffer from the
  908.    *   partial read of the segment.
  909.    * @return {!Promise}
  910.    */
  911.   async appendBuffer(
  912.       contentType, data, reference, stream, hasClosedCaptions, seeked = false,
  913.       adaptation = false, isChunkedData = false, fromSplit = false) {
  914.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  916.     if (contentType == ContentType.TEXT) {
  917.       if (this.manifestType_ == shaka.media.ManifestParser.HLS) {
  918.         // This won't be known until the first video segment is appended.
  919.         const offset = await this.textSequenceModeOffset_;
  920.         this.textEngine_.setTimestampOffset(offset);
  921.       }
  922.       await this.textEngine_.appendBuffer(
  923.           data,
  924.           reference ? reference.startTime : null,
  925.           reference ? reference.endTime : null,
  926.           reference ? reference.getUris()[0] : null);
  927.       return;
  928.     }
  930.     if (!fromSplit && this.needSplitMuxedContent_) {
  931.       await this.appendBuffer(ContentType.AUDIO, data, reference, stream,
  932.           hasClosedCaptions, seeked, adaptation, isChunkedData,
  933.           /* fromSplit= */ true);
  934.       await this.appendBuffer(ContentType.VIDEO, data, reference, stream,
  935.           hasClosedCaptions, seeked, adaptation, isChunkedData,
  936.           /* fromSplit= */ true);
  937.       return;
  938.     }
  940.     if (!this.sourceBuffers_[contentType]) {
  941.       shaka.log.warning('Attempted to restore a non-existent source buffer');
  942.       return;
  943.     }
  945.     let timestampOffset = this.sourceBuffers_[contentType].timestampOffset;
  947.     let mimeType = this.sourceBufferTypes_[contentType];
  948.     if (this.transmuxers_[contentType]) {
  949.       mimeType = this.transmuxers_[contentType].getOriginalMimeType();
  950.     }
  951.     if (reference) {
  952.       const {timestamp, metadata} = this.getTimestampAndDispatchMetadata_(
  953.           contentType, data, reference, mimeType);
  954.       if (timestamp != null) {
  955.         if (this.firstVideoTimestamp_ == null &&
  956.             contentType == ContentType.VIDEO) {
  957.           this.firstVideoTimestamp_ = timestamp;
  958.           this.firstVideoReferenceStartTime_ = reference.startTime;
  959.           if (this.firstAudioTimestamp_ != null) {
  960.             let compensation = 0;
  961.             // Only apply compensation if video and audio segment startTime
  962.             // match, to avoid introducing sync issues.
  963.             if (this.firstVideoReferenceStartTime_ ==
  964.                 this.firstAudioReferenceStartTime_) {
  965.               compensation =
  966.                   this.firstVideoTimestamp_ - this.firstAudioTimestamp_;
  967.             }
  968.             this.audioCompensation_.resolve(compensation);
  969.           }
  970.         }
  971.         if (this.firstAudioTimestamp_ == null &&
  972.             contentType == ContentType.AUDIO) {
  973.           this.firstAudioTimestamp_ = timestamp;
  974.           this.firstAudioReferenceStartTime_ = reference.startTime;
  975.           if (this.firstVideoTimestamp_ != null) {
  976.             let compensation = 0;
  977.             // Only apply compensation if video and audio segment startTime
  978.             // match, to avoid introducing sync issues.
  979.             if (this.firstVideoReferenceStartTime_ ==
  980.                 this.firstAudioReferenceStartTime_) {
  981.               compensation =
  982.                   this.firstVideoTimestamp_ - this.firstAudioTimestamp_;
  983.             }
  984.             this.audioCompensation_.resolve(compensation);
  985.           }
  986.         }
  987.         let realTimestamp = timestamp;
  988.         const RAW_FORMATS = shaka.util.MimeUtils.RAW_FORMATS;
  989.         // For formats without containers and using segments mode, we need to
  990.         // adjust TimestampOffset relative to 0 because segments do not have
  991.         // any timestamp information.
  992.         if (!this.sequenceMode_ &&
  993.             RAW_FORMATS.includes(this.sourceBufferTypes_[contentType])) {
  994.           realTimestamp = 0;
  995.         }
  996.         const calculatedTimestampOffset = reference.startTime - realTimestamp;
  997.         const timestampOffsetDifference =
  998.             Math.abs(timestampOffset - calculatedTimestampOffset);
  999.         if ((timestampOffsetDifference >= 0.001 || seeked || adaptation) &&
  1000.             (!isChunkedData || calculatedTimestampOffset > 0 ||
  1001.             !timestampOffset)) {
  1002.           timestampOffset = calculatedTimestampOffset;
  1003.           if (this.attemptTimestampOffsetCalculation_) {
  1004.             this.enqueueOperation_(
  1005.                 contentType,
  1006.                 () => this.abort_(contentType),
  1007.                 null);
  1008.             this.enqueueOperation_(
  1009.                 contentType,
  1010.                 () => this.setTimestampOffset_(contentType, timestampOffset),
  1011.                 null);
  1012.           }
  1013.         }
  1014.         // Timestamps can only be reliably extracted from video, not audio.
  1015.         // Packed audio formats do not have internal timestamps at all.
  1016.         // Prefer video for this when available.
  1017.         const isBestSourceBufferForTimestamps =
  1018.             contentType == ContentType.VIDEO ||
  1019.             !(ContentType.VIDEO in this.sourceBuffers_);
  1020.         if (isBestSourceBufferForTimestamps) {
  1021.           this.textSequenceModeOffset_.resolve(timestampOffset);
  1022.         }
  1023.       }
  1024.       if (metadata.length) {
  1025.         this.playerInterface_.onMetadata(metadata, timestampOffset,
  1026.             reference ? reference.endTime : null);
  1027.       }
  1028.     }
  1029.     if (hasClosedCaptions && contentType == ContentType.VIDEO) {
  1030.       if (!this.textEngine_) {
  1031.         this.reinitText(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE,
  1032.             this.sequenceMode_, /* external= */ false);
  1033.       }
  1034.       if (!this.captionParser_) {
  1035.         const basicType = mimeType.split(';', 1)[0];
  1036.         this.captionParser_ = this.getCaptionParser(basicType);
  1037.       }
  1038.       // If it is the init segment for closed captions, initialize the closed
  1039.       // caption parser.
  1040.       if (!reference) {
  1041.         this.captionParser_.init(data, adaptation);
  1042.       } else {
  1043.         const closedCaptions = this.captionParser_.parseFrom(data);
  1044.         if (closedCaptions.length) {
  1045.           this.textEngine_.storeAndAppendClosedCaptions(
  1046.               closedCaptions,
  1047.               reference.startTime,
  1048.               reference.endTime,
  1049.               timestampOffset);
  1050.         }
  1051.       }
  1052.     }
  1054.     if (this.transmuxers_[contentType]) {
  1055.       data = await this.transmuxers_[contentType].transmux(
  1056.           data, stream, reference, this.mediaSource_.duration, contentType);
  1057.     }
  1059.     data = this.workAroundBrokenPlatforms_(
  1060.         data, reference ? reference.startTime : null, contentType,
  1061.         reference ? reference.getUris()[0] : null);
  1063.     if (reference && this.sequenceMode_ && contentType != ContentType.TEXT) {
  1064.       // In sequence mode, for non-text streams, if we just cleared the buffer
  1065.       // and are either performing an unbuffered seek or handling an automatic
  1066.       // adaptation, we need to set a new timestampOffset on the sourceBuffer.
  1067.       if (seeked || adaptation) {
  1068.         let timestampOffset = reference.startTime;
  1069.         // Audio and video may not be aligned, so we will compensate for audio
  1070.         // if necessary.
  1071.         if (this.manifestType_ == shaka.media.ManifestParser.HLS &&
  1072.             !this.needSplitMuxedContent_ &&
  1073.             contentType == ContentType.AUDIO &&
  1074.             this.sourceBuffers_[ContentType.VIDEO]) {
  1075.           const compensation = await this.audioCompensation_;
  1076.           // Only apply compensation if the difference is greater than 100ms
  1077.           if (Math.abs(compensation) > 0.1) {
  1078.             timestampOffset -= compensation;
  1079.           }
  1080.         }
  1081.         // The logic to call abort() before setting the timestampOffset is
  1082.         // extended during unbuffered seeks or automatic adaptations; it is
  1083.         // possible for the append state to be PARSING_MEDIA_SEGMENT from the
  1084.         // previous SourceBuffer#appendBuffer() call.
  1085.         this.enqueueOperation_(
  1086.             contentType,
  1087.             () => this.abort_(contentType),
  1088.             null);
  1089.         this.enqueueOperation_(
  1090.             contentType,
  1091.             () => this.setTimestampOffset_(contentType, timestampOffset),
  1092.             null);
  1093.       }
  1094.     }
  1096.     let bufferedBefore = null;
  1098.     await this.enqueueOperation_(contentType, () => {
  1099.       if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
  1100.         bufferedBefore = this.getBuffered_(contentType);
  1101.       }
  1102.       this.append_(contentType, data, timestampOffset);
  1103.     }, reference ? reference.getUris()[0] : null);
  1105.     if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
  1106.       const bufferedAfter = this.getBuffered_(contentType);
  1107.       const newBuffered = shaka.media.TimeRangesUtils.computeAddedRange(
  1108.           bufferedBefore, bufferedAfter);
  1109.       if (newBuffered) {
  1110.         const segmentDuration = reference.endTime - reference.startTime;
  1111.         const timeAdded = newBuffered.end - newBuffered.start;
  1112.         // Check end times instead of start times.  We may be overwriting a
  1113.         // buffer and only the end changes, and that would be fine.
  1114.         // Also, exclude tiny segments.  Sometimes alignment segments as small
  1115.         // as 33ms are seen in Google DAI content.  For such tiny segments,
  1116.         // half a segment duration would be no issue.
  1117.         const offset = Math.abs(newBuffered.end - reference.endTime);
  1118.         if (segmentDuration > 0.100 && (offset > segmentDuration / 2 ||
  1119.             Math.abs(segmentDuration - timeAdded) > 0.030)) {
  1120.           shaka.log.error('Possible encoding problem detected!',
  1121.               'Unexpected buffered range for reference', reference,
  1122.               'from URIs', reference.getUris(),
  1123.               'should be', {start: reference.startTime, end: reference.endTime},
  1124.               'but got', newBuffered);
  1125.         }
  1126.       }
  1127.     }
  1128.   }
  1130.   /**
  1131.    * Set the selected closed captions Id and language.
  1132.    *
  1133.    * @param {string} id
  1134.    */
  1135.   setSelectedClosedCaptionId(id) {
  1136.     const VIDEO = shaka.util.ManifestParserUtils.ContentType.VIDEO;
  1137.     const videoBufferEndTime = this.bufferEnd(VIDEO) || 0;
  1138.     this.textEngine_.setSelectedClosedCaptionId(id, videoBufferEndTime);
  1139.   }
  1141.   /** Disable embedded closed captions. */
  1142.   clearSelectedClosedCaptionId() {
  1143.     if (this.textEngine_) {
  1144.       this.textEngine_.setSelectedClosedCaptionId('', 0);
  1145.     }
  1146.   }
  1148.   /**
  1149.    * Enqueue an operation to remove data from the SourceBuffer.
  1150.    *
  1151.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1152.    * @param {number} startTime relative to the start of the presentation
  1153.    * @param {number} endTime relative to the start of the presentation
  1154.    * @return {!Promise}
  1155.    */
  1156.   async remove(contentType, startTime, endTime) {
  1157.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1158.     if (contentType == ContentType.TEXT) {
  1159.       await this.textEngine_.remove(startTime, endTime);
  1160.     } else {
  1161.       await this.enqueueOperation_(
  1162.           contentType,
  1163.           () => this.remove_(contentType, startTime, endTime),
  1164.           null);
  1165.       if (this.needSplitMuxedContent_) {
  1166.         await this.enqueueOperation_(
  1167.             ContentType.AUDIO,
  1168.             () => this.remove_(ContentType.AUDIO, startTime, endTime),
  1169.             null);
  1170.       }
  1171.     }
  1172.   }
  1174.   /**
  1175.    * Enqueue an operation to clear the SourceBuffer.
  1176.    *
  1177.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1178.    * @return {!Promise}
  1179.    */
  1180.   async clear(contentType) {
  1181.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1182.     if (contentType == ContentType.TEXT) {
  1183.       if (!this.textEngine_) {
  1184.         return;
  1185.       }
  1186.       await this.textEngine_.remove(0, Infinity);
  1187.     } else {
  1188.       // Note that not all platforms allow clearing to Infinity.
  1189.       await this.enqueueOperation_(
  1190.           contentType,
  1191.           () => this.remove_(contentType, 0, this.mediaSource_.duration),
  1192.           null);
  1193.       if (this.needSplitMuxedContent_) {
  1194.         await this.enqueueOperation_(
  1195.             ContentType.AUDIO,
  1196.             () => this.remove_(
  1197.                 ContentType.AUDIO, 0, this.mediaSource_.duration),
  1198.             null);
  1199.       }
  1200.     }
  1201.   }
  1203.   /**
  1204.    * Fully reset the state of the caption parser owned by MediaSourceEngine.
  1205.    */
  1206.   resetCaptionParser() {
  1207.     if (this.captionParser_) {
  1208.       this.captionParser_.reset();
  1209.     }
  1210.   }
  1212.   /**
  1213.    * Enqueue an operation to flush the SourceBuffer.
  1214.    * This is a workaround for what we believe is a Chromecast bug.
  1215.    *
  1216.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1217.    * @return {!Promise}
  1218.    */
  1219.   async flush(contentType) {
  1220.     // Flush the pipeline.  Necessary on Chromecast, even though we have removed
  1221.     // everything.
  1222.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1223.     if (contentType == ContentType.TEXT) {
  1224.       // Nothing to flush for text.
  1225.       return;
  1226.     }
  1227.     await this.enqueueOperation_(
  1228.         contentType,
  1229.         () => this.flush_(contentType),
  1230.         null);
  1231.     if (this.needSplitMuxedContent_) {
  1232.       await this.enqueueOperation_(
  1233.           ContentType.AUDIO,
  1234.           () => this.flush_(ContentType.AUDIO),
  1235.           null);
  1236.     }
  1237.   }
  1239.   /**
  1240.    * Sets the timestamp offset and append window end for the given content type.
  1241.    *
  1242.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1243.    * @param {number} timestampOffset The timestamp offset.  Segments which start
  1244.    *   at time t will be inserted at time t + timestampOffset instead.  This
  1245.    *   value does not affect segments which have already been inserted.
  1246.    * @param {number} appendWindowStart The timestamp to set the append window
  1247.    *   start to.  For future appends, frames/samples with timestamps less than
  1248.    *   this value will be dropped.
  1249.    * @param {number} appendWindowEnd The timestamp to set the append window end
  1250.    *   to.  For future appends, frames/samples with timestamps greater than this
  1251.    *   value will be dropped.
  1252.    * @param {boolean} ignoreTimestampOffset  If true, the timestampOffset will
  1253.    *   not be applied in this step.
  1254.    * @param {string} mimeType
  1255.    * @param {string} codecs
  1256.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  1257.    *               shaka.extern.Stream>} streamsByType
  1258.    *   A map of content types to streams.  All streams must be supported
  1259.    *   according to MediaSourceEngine.isStreamSupported.
  1260.    *
  1261.    * @return {!Promise}
  1262.    */
  1263.   async setStreamProperties(
  1264.       contentType, timestampOffset, appendWindowStart, appendWindowEnd,
  1265.       ignoreTimestampOffset, mimeType, codecs, streamsByType) {
  1266.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1267.     if (contentType == ContentType.TEXT) {
  1268.       if (!ignoreTimestampOffset) {
  1269.         this.textEngine_.setTimestampOffset(timestampOffset);
  1270.       }
  1271.       this.textEngine_.setAppendWindow(appendWindowStart, appendWindowEnd);
  1272.       return;
  1273.     }
  1274.     const operations = [];
  1276.     const hasChangedCodecs = await this.codecSwitchIfNecessary_(
  1277.         contentType, mimeType, codecs, streamsByType);
  1279.     if (!hasChangedCodecs) {
  1280.       // Queue an abort() to help MSE splice together overlapping segments.
  1281.       // We set appendWindowEnd when we change periods in DASH content, and the
  1282.       // period transition may result in overlap.
  1283.       //
  1284.       // An abort() also helps with MPEG2-TS.  When we append a TS segment, we
  1285.       // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
  1286.       // timestamp offset.  By calling abort(), we reset the state so we can
  1287.       // set it.
  1288.       operations.push(this.enqueueOperation_(
  1289.           contentType,
  1290.           () => this.abort_(contentType),
  1291.           null));
  1292.       if (this.needSplitMuxedContent_) {
  1293.         operations.push(this.enqueueOperation_(
  1294.             ContentType.AUDIO,
  1295.             () => this.abort_(ContentType.AUDIO),
  1296.             null));
  1297.       }
  1298.     }
  1299.     if (!ignoreTimestampOffset) {
  1300.       operations.push(this.enqueueOperation_(
  1301.           contentType,
  1302.           () => this.setTimestampOffset_(contentType, timestampOffset),
  1303.           null));
  1304.       if (this.needSplitMuxedContent_) {
  1305.         operations.push(this.enqueueOperation_(
  1306.             ContentType.AUDIO,
  1307.             () => this.setTimestampOffset_(
  1308.                 ContentType.AUDIO, timestampOffset),
  1309.             null));
  1310.       }
  1311.     }
  1312.     operations.push(this.enqueueOperation_(
  1313.         contentType,
  1314.         () => this.setAppendWindow_(
  1315.             contentType, appendWindowStart, appendWindowEnd),
  1316.         null));
  1317.     if (this.needSplitMuxedContent_) {
  1318.       operations.push(this.enqueueOperation_(
  1319.           ContentType.AUDIO,
  1320.           () => this.setAppendWindow_(
  1321.               ContentType.AUDIO, appendWindowStart, appendWindowEnd),
  1322.           null));
  1323.     }
  1325.     await Promise.all(operations);
  1326.   }
  1328.   /**
  1329.    * Adjust timestamp offset to maintain AV sync across discontinuities.
  1330.    *
  1331.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1332.    * @param {number} timestampOffset
  1333.    * @return {!Promise}
  1334.    */
  1335.   async resync(contentType, timestampOffset) {
  1336.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1338.     if (contentType == ContentType.TEXT) {
  1339.       // This operation is for audio and video only.
  1340.       return;
  1341.     }
  1343.     // Reset the promise in case the timestamp offset changed during
  1344.     // a period/discontinuity transition.
  1345.     if (contentType == ContentType.VIDEO) {
  1346.       this.textSequenceModeOffset_ = new shaka.util.PublicPromise();
  1347.     }
  1349.     if (!this.sequenceMode_) {
  1350.       return;
  1351.     }
  1353.     // Avoid changing timestampOffset when the difference is less than 100 ms
  1354.     // from the end of the current buffer.
  1355.     const bufferEnd = this.bufferEnd(contentType);
  1356.     if (bufferEnd && Math.abs(bufferEnd - timestampOffset) < 0.1) {
  1357.       return;
  1358.     }
  1360.     // Queue an abort() to help MSE splice together overlapping segments.
  1361.     // We set appendWindowEnd when we change periods in DASH content, and the
  1362.     // period transition may result in overlap.
  1363.     //
  1364.     // An abort() also helps with MPEG2-TS.  When we append a TS segment, we
  1365.     // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
  1366.     // timestamp offset.  By calling abort(), we reset the state so we can
  1367.     // set it.
  1368.     this.enqueueOperation_(
  1369.         contentType,
  1370.         () => this.abort_(contentType),
  1371.         null);
  1372.     if (this.needSplitMuxedContent_) {
  1373.       this.enqueueOperation_(
  1374.           ContentType.AUDIO,
  1375.           () => this.abort_(ContentType.AUDIO),
  1376.           null);
  1377.     }
  1378.     await this.enqueueOperation_(
  1379.         contentType,
  1380.         () => this.setTimestampOffset_(contentType, timestampOffset),
  1381.         null);
  1382.     if (this.needSplitMuxedContent_) {
  1383.       await this.enqueueOperation_(
  1384.           ContentType.AUDIO,
  1385.           () => this.setTimestampOffset_(ContentType.AUDIO, timestampOffset),
  1386.           null);
  1387.     }
  1388.   }
  1390.   /**
  1391.    * @param {string=} reason Valid reasons are 'network' and 'decode'.
  1392.    * @return {!Promise}
  1393.    * @see http://w3c.github.io/media-source/#idl-def-EndOfStreamError
  1394.    */
  1395.   async endOfStream(reason) {
  1396.     await this.enqueueBlockingOperation_(() => {
  1397.       // If endOfStream() has already been called on the media source,
  1398.       // don't call it again. Also do not call if readyState is
  1399.       // 'closed' (not attached to video element) since it is not a
  1400.       // valid operation.
  1401.       if (this.ended() || this.closed()) {
  1402.         return;
  1403.       }
  1404.       // Tizen won't let us pass undefined, but it will let us omit the
  1405.       // argument.
  1406.       if (reason) {
  1407.         this.mediaSource_.endOfStream(reason);
  1408.       } else {
  1409.         this.mediaSource_.endOfStream();
  1410.       }
  1411.     });
  1412.   }
  1414.   /**
  1415.    * @param {number} duration
  1416.    * @return {!Promise}
  1417.    */
  1418.   async setDuration(duration) {
  1419.     await this.enqueueBlockingOperation_(() => {
  1420.       // Reducing the duration causes the MSE removal algorithm to run, which
  1421.       // triggers an 'updateend' event to fire.  To handle this scenario, we
  1422.       // have to insert a dummy operation into the beginning of each queue,
  1423.       // which the 'updateend' handler will remove.
  1424.       if (duration < this.mediaSource_.duration) {
  1425.         for (const contentType in this.sourceBuffers_) {
  1426.           const dummyOperation = {
  1427.             start: () => {},
  1428.             p: new shaka.util.PublicPromise(),
  1429.             uri: null,
  1430.           };
  1431.           this.queues_[contentType].unshift(dummyOperation);
  1432.         }
  1433.       }
  1435.       this.mediaSource_.duration = duration;
  1436.       this.lastDuration_ = duration;
  1437.     });
  1438.   }
  1440.   /**
  1441.    * Get the current MediaSource duration.
  1442.    *
  1443.    * @return {number}
  1444.    */
  1445.   getDuration() {
  1446.     return this.mediaSource_.duration;
  1447.   }
  1449.   /**
  1450.    * Append data to the SourceBuffer.
  1451.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1452.    * @param {BufferSource} data
  1453.    * @param {number} timestampOffset
  1454.    * @private
  1455.    */
  1456.   append_(contentType, data, timestampOffset) {
  1457.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1459.     // Append only video data to the LCEVC Dec.
  1460.     if (contentType == ContentType.VIDEO && this.lcevcDec_) {
  1461.       // Append video buffers to the LCEVC Dec for parsing and storing
  1462.       // of LCEVC data.
  1463.       this.lcevcDec_.appendBuffer(data, timestampOffset);
  1464.     }
  1466.     // This will trigger an 'updateend' event.
  1467.     this.sourceBuffers_[contentType].appendBuffer(data);
  1468.   }
  1470.   /**
  1471.    * Remove data from the SourceBuffer.
  1472.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1473.    * @param {number} startTime relative to the start of the presentation
  1474.    * @param {number} endTime relative to the start of the presentation
  1475.    * @private
  1476.    */
  1477.   remove_(contentType, startTime, endTime) {
  1478.     if (endTime <= startTime) {
  1479.       // Ignore removal of inverted or empty ranges.
  1480.       // Fake 'updateend' event to resolve the operation.
  1481.       this.onUpdateEnd_(contentType);
  1482.       return;
  1483.     }
  1485.     // This will trigger an 'updateend' event.
  1486.     this.sourceBuffers_[contentType].remove(startTime, endTime);
  1487.   }
  1489.   /**
  1490.    * Call abort() on the SourceBuffer.
  1491.    * This resets MSE's last_decode_timestamp on all track buffers, which should
  1492.    * trigger the splicing logic for overlapping segments.
  1493.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1494.    * @private
  1495.    */
  1496.   abort_(contentType) {
  1497.     // Save the append window, which is reset on abort().
  1498.     const appendWindowStart =
  1499.         this.sourceBuffers_[contentType].appendWindowStart;
  1500.     const appendWindowEnd = this.sourceBuffers_[contentType].appendWindowEnd;
  1502.     // This will not trigger an 'updateend' event, since nothing is happening.
  1503.     // This is only to reset MSE internals, not to abort an actual operation.
  1504.     this.sourceBuffers_[contentType].abort();
  1506.     // Restore the append window.
  1507.     this.sourceBuffers_[contentType].appendWindowStart = appendWindowStart;
  1508.     this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
  1510.     // Fake an 'updateend' event to resolve the operation.
  1511.     this.onUpdateEnd_(contentType);
  1512.   }
  1514.   /**
  1515.    * Nudge the playhead to force the media pipeline to be flushed.
  1516.    * This seems to be necessary on Chromecast to get new content to replace old
  1517.    * content.
  1518.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1519.    * @private
  1520.    */
  1521.   flush_(contentType) {
  1522.     // Never use flush_ if there's data.  It causes a hiccup in playback.
  1523.     goog.asserts.assert(
  1524.         this.video_.buffered.length == 0, 'MediaSourceEngine.flush_ should ' +
  1525.         'only be used after clearing all data!');
  1527.     // Seeking forces the pipeline to be flushed.
  1528.     this.video_.currentTime -= 0.001;
  1530.     // Fake an 'updateend' event to resolve the operation.
  1531.     this.onUpdateEnd_(contentType);
  1532.   }
  1534.   /**
  1535.    * Set the SourceBuffer's timestamp offset.
  1536.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1537.    * @param {number} timestampOffset
  1538.    * @private
  1539.    */
  1540.   setTimestampOffset_(contentType, timestampOffset) {
  1541.     // Work around for
  1542.     // https://github.com/shaka-project/shaka-player/issues/1281:
  1543.     // TODO(https://bit.ly/2ttKiBU): follow up when this is fixed in Edge
  1544.     if (timestampOffset < 0) {
  1545.       // Try to prevent rounding errors in Edge from removing the first
  1546.       // keyframe.
  1547.       timestampOffset += 0.001;
  1548.     }
  1550.     this.sourceBuffers_[contentType].timestampOffset = timestampOffset;
  1552.     // Fake an 'updateend' event to resolve the operation.
  1553.     this.onUpdateEnd_(contentType);
  1554.   }
  1556.   /**
  1557.    * Set the SourceBuffer's append window end.
  1558.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1559.    * @param {number} appendWindowStart
  1560.    * @param {number} appendWindowEnd
  1561.    * @private
  1562.    */
  1563.   setAppendWindow_(contentType, appendWindowStart, appendWindowEnd) {
  1564.     // You can't set start > end, so first set start to 0, then set the new
  1565.     // end, then set the new start.  That way, there are no intermediate
  1566.     // states which are invalid.
  1567.     this.sourceBuffers_[contentType].appendWindowStart = 0;
  1568.     this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
  1569.     this.sourceBuffers_[contentType].appendWindowStart = appendWindowStart;
  1571.     // Fake an 'updateend' event to resolve the operation.
  1572.     this.onUpdateEnd_(contentType);
  1573.   }
  1575.   /**
  1576.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1577.    * @private
  1578.    */
  1579.   onError_(contentType) {
  1580.     const operation = this.queues_[contentType][0];
  1581.     goog.asserts.assert(operation, 'Spurious error event!');
  1582.     goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
  1583.         'SourceBuffer should not be updating on error!');
  1584.     const code = this.video_.error ? this.video_.error.code : 0;
  1585.     operation.p.reject(new shaka.util.Error(
  1586.         shaka.util.Error.Severity.CRITICAL,
  1587.         shaka.util.Error.Category.MEDIA,
  1588.         shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_FAILED,
  1589.         code, operation.uri));
  1590.     // Do not pop from queue.  An 'updateend' event will fire next, and to
  1591.     // avoid synchronizing these two event handlers, we will allow that one to
  1592.     // pop from the queue as normal.  Note that because the operation has
  1593.     // already been rejected, the call to resolve() in the 'updateend' handler
  1594.     // will have no effect.
  1595.   }
  1597.   /**
  1598.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1599.    * @private
  1600.    */
  1601.   onUpdateEnd_(contentType) {
  1602.     if (this.reloadingMediaSource_) {
  1603.       return;
  1604.     }
  1605.     const operation = this.queues_[contentType][0];
  1606.     goog.asserts.assert(operation, 'Spurious updateend event!');
  1607.     if (!operation) {
  1608.       return;
  1609.     }
  1610.     goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
  1611.         'SourceBuffer should not be updating on updateend!');
  1612.     operation.p.resolve();
  1613.     this.popFromQueue_(contentType);
  1614.   }
  1616.   /**
  1617.    * Enqueue an operation and start it if appropriate.
  1618.    *
  1619.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1620.    * @param {function()} start
  1621.    * @param {?string} uri
  1622.    * @return {!Promise}
  1623.    * @private
  1624.    */
  1625.   enqueueOperation_(contentType, start, uri) {
  1626.     this.destroyer_.ensureNotDestroyed();
  1627.     const operation = {
  1628.       start: start,
  1629.       p: new shaka.util.PublicPromise(),
  1630.       uri,
  1631.     };
  1632.     this.queues_[contentType].push(operation);
  1634.     if (this.queues_[contentType].length == 1) {
  1635.       this.startOperation_(contentType);
  1636.     }
  1637.     return operation.p;
  1638.   }
  1640.   /**
  1641.    * Enqueue an operation which must block all other operations on all
  1642.    * SourceBuffers.
  1643.    *
  1644.    * @param {function():(Promise|undefined)} run
  1645.    * @return {!Promise}
  1646.    * @private
  1647.    */
  1648.   async enqueueBlockingOperation_(run) {
  1649.     this.destroyer_.ensureNotDestroyed();
  1651.     /** @type {!Array.<!shaka.util.PublicPromise>} */
  1652.     const allWaiters = [];
  1654.     // Enqueue a 'wait' operation onto each queue.
  1655.     // This operation signals its readiness when it starts.
  1656.     // When all wait operations are ready, the real operation takes place.
  1657.     for (const contentType in this.sourceBuffers_) {
  1658.       const ready = new shaka.util.PublicPromise();
  1659.       const operation = {
  1660.         start: () => ready.resolve(),
  1661.         p: ready,
  1662.         uri: null,
  1663.       };
  1665.       this.queues_[contentType].push(operation);
  1666.       allWaiters.push(ready);
  1668.       if (this.queues_[contentType].length == 1) {
  1669.         operation.start();
  1670.       }
  1671.     }
  1673.     // Return a Promise to the real operation, which waits to begin until
  1674.     // there are no other in-progress operations on any SourceBuffers.
  1675.     try {
  1676.       await Promise.all(allWaiters);
  1677.     } catch (error) {
  1678.       // One of the waiters failed, which means we've been destroyed.
  1679.       goog.asserts.assert(
  1680.           this.destroyer_.destroyed(), 'Should be destroyed by now');
  1681.       // We haven't popped from the queue.  Canceled waiters have been removed
  1682.       // by destroy.  What's left now should just be resolved waiters.  In
  1683.       // uncompiled mode, we will maintain good hygiene and make sure the
  1684.       // assert at the end of destroy passes.  In compiled mode, the queues
  1685.       // are wiped in destroy.
  1686.       if (goog.DEBUG) {
  1687.         for (const contentType in this.sourceBuffers_) {
  1688.           if (this.queues_[contentType].length) {
  1689.             goog.asserts.assert(
  1690.                 this.queues_[contentType].length == 1,
  1691.                 'Should be at most one item in queue!');
  1692.             goog.asserts.assert(
  1693.                 allWaiters.includes(this.queues_[contentType][0].p),
  1694.                 'The item in queue should be one of our waiters!');
  1695.             this.queues_[contentType].shift();
  1696.           }
  1697.         }
  1698.       }
  1699.       throw error;
  1700.     }
  1702.     if (goog.DEBUG) {
  1703.       // If we did it correctly, nothing is updating.
  1704.       for (const contentType in this.sourceBuffers_) {
  1705.         goog.asserts.assert(
  1706.             this.sourceBuffers_[contentType].updating == false,
  1707.             'SourceBuffers should not be updating after a blocking op!');
  1708.       }
  1709.     }
  1711.     // Run the real operation, which can be asynchronous.
  1712.     try {
  1713.       await run();
  1714.     } catch (exception) {
  1715.       throw new shaka.util.Error(
  1716.           shaka.util.Error.Severity.CRITICAL,
  1717.           shaka.util.Error.Category.MEDIA,
  1718.           shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  1719.           exception,
  1720.           this.video_.error || 'No error in the media element',
  1721.           null);
  1722.     } finally {
  1723.       // Unblock the queues.
  1724.       for (const contentType in this.sourceBuffers_) {
  1725.         this.popFromQueue_(contentType);
  1726.       }
  1727.     }
  1728.   }
  1730.   /**
  1731.    * Pop from the front of the queue and start a new operation.
  1732.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1733.    * @private
  1734.    */
  1735.   popFromQueue_(contentType) {
  1736.     // Remove the in-progress operation, which is now complete.
  1737.     this.queues_[contentType].shift();
  1738.     this.startOperation_(contentType);
  1739.   }
  1741.   /**
  1742.    * Starts the next operation in the queue.
  1743.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1744.    * @private
  1745.    */
  1746.   startOperation_(contentType) {
  1747.     // Retrieve the next operation, if any, from the queue and start it.
  1748.     const next = this.queues_[contentType][0];
  1749.     if (next) {
  1750.       try {
  1751.         next.start();
  1752.       } catch (exception) {
  1753.         if (exception.name == 'QuotaExceededError') {
  1754.           next.p.reject(new shaka.util.Error(
  1755.               shaka.util.Error.Severity.CRITICAL,
  1756.               shaka.util.Error.Category.MEDIA,
  1757.               shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR,
  1758.               contentType));
  1759.         } else {
  1760.           next.p.reject(new shaka.util.Error(
  1761.               shaka.util.Error.Severity.CRITICAL,
  1762.               shaka.util.Error.Category.MEDIA,
  1763.               shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  1764.               exception,
  1765.               this.video_.error || 'No error in the media element',
  1766.               next.uri));
  1767.         }
  1768.         this.popFromQueue_(contentType);
  1769.       }
  1770.     }
  1771.   }
  1773.   /**
  1774.    * @return {!shaka.extern.TextDisplayer}
  1775.    */
  1776.   getTextDisplayer() {
  1777.     goog.asserts.assert(
  1778.         this.textDisplayer_,
  1779.         'TextDisplayer should only be null when this is destroyed');
  1781.     return this.textDisplayer_;
  1782.   }
  1784.   /**
  1785.    * @param {!shaka.extern.TextDisplayer} textDisplayer
  1786.    */
  1787.   setTextDisplayer(textDisplayer) {
  1788.     const oldTextDisplayer = this.textDisplayer_;
  1789.     this.textDisplayer_ = textDisplayer;
  1790.     if (oldTextDisplayer) {
  1791.       textDisplayer.setTextVisibility(oldTextDisplayer.isTextVisible());
  1792.       oldTextDisplayer.destroy();
  1793.     }
  1794.     if (this.textEngine_) {
  1795.       this.textEngine_.setDisplayer(textDisplayer);
  1796.     }
  1797.   }
  1799.   /**
  1800.    * @param {boolean} segmentRelativeVttTiming
  1801.    */
  1802.   setSegmentRelativeVttTiming(segmentRelativeVttTiming) {
  1803.     this.segmentRelativeVttTiming_ = segmentRelativeVttTiming;
  1804.   }
  1806.   /**
  1807.    * Apply platform-specific transformations to this segment to work around
  1808.    * issues in the platform.
  1809.    *
  1810.    * @param {!BufferSource} segment
  1811.    * @param {?number} startTime
  1812.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1813.    * @param {?string} uri
  1814.    * @return {!BufferSource}
  1815.    * @private
  1816.    */
  1817.   workAroundBrokenPlatforms_(segment, startTime, contentType, uri) {
  1818.     const Platform = shaka.util.Platform;
  1820.     const isInitSegment = startTime == null;
  1821.     const encryptionExpected = this.expectedEncryption_[contentType];
  1822.     const keySystem = this.playerInterface_.getKeySystem();
  1824.     // If:
  1825.     //   1. the configuration tells to insert fake encryption,
  1826.     //   2. and this is an init segment,
  1827.     //   3. and encryption is expected,
  1828.     //   4. and the platform requires encryption in all init segments,
  1829.     //   5. and the content is MP4 (mimeType == "video/mp4" or "audio/mp4"),
  1830.     // then insert fake encryption metadata for init segments that lack it.
  1831.     // The MP4 requirement is because we can currently only do this
  1832.     // transformation on MP4 containers.
  1833.     // See: https://github.com/shaka-project/shaka-player/issues/2759
  1834.     if (this.config_.insertFakeEncryptionInInit &&
  1835.         isInitSegment &&
  1836.         encryptionExpected &&
  1837.         Platform.requiresEncryptionInfoInAllInitSegments(keySystem) &&
  1838.         shaka.util.MimeUtils.getContainerType(
  1839.             this.sourceBufferTypes_[contentType]) == 'mp4') {
  1840.       shaka.log.debug('Forcing fake encryption information in init segment.');
  1841.       segment = shaka.media.ContentWorkarounds.fakeEncryption(segment, uri);
  1842.     }
  1844.     return segment;
  1845.   }
  1847.   /**
  1848.    * Prepare the SourceBuffer to parse a potentially new type or codec.
  1849.    *
  1850.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1851.    * @param {string} mimeType
  1852.    * @param {?shaka.extern.Transmuxer} transmuxer
  1853.    * @private
  1854.    */
  1855.   change_(contentType, mimeType, transmuxer) {
  1856.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1857.     if (contentType === ContentType.TEXT) {
  1858.       shaka.log.debug(`Change not supported for ${contentType}`);
  1859.       return;
  1860.     }
  1861.     shaka.log.debug(
  1862.         `Change Type: ${this.sourceBufferTypes_[contentType]} -> ${mimeType}`);
  1863.     if (shaka.media.Capabilities.isChangeTypeSupported()) {
  1864.       if (this.transmuxers_[contentType]) {
  1865.         this.transmuxers_[contentType].destroy();
  1866.         delete this.transmuxers_[contentType];
  1867.       }
  1868.       if (transmuxer) {
  1869.         this.transmuxers_[contentType] = transmuxer;
  1870.       }
  1871.       const type = this.addExtraFeaturesToMimeType_(mimeType);
  1872.       this.sourceBuffers_[contentType].changeType(type);
  1873.       this.sourceBufferTypes_[contentType] = mimeType;
  1874.     } else {
  1875.       shaka.log.debug('Change Type not supported');
  1876.     }
  1878.     // Fake an 'updateend' event to resolve the operation.
  1879.     this.onUpdateEnd_(contentType);
  1880.   }
  1882.   /**
  1883.    * Enqueue an operation to prepare the SourceBuffer to parse a potentially new
  1884.    * type or codec.
  1885.    *
  1886.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1887.    * @param {string} mimeType
  1888.    * @param {?shaka.extern.Transmuxer} transmuxer
  1889.    * @return {!Promise}
  1890.    */
  1891.   changeType(contentType, mimeType, transmuxer) {
  1892.     return this.enqueueOperation_(
  1893.         contentType,
  1894.         () => this.change_(contentType, mimeType, transmuxer),
  1895.         null);
  1896.   }
  1898.   /**
  1899.    * Returns the source buffer parameters
  1900.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1901.    * @return {?shaka.media.MediaSourceEngine.SourceBufferParams}
  1902.    * @private
  1903.    */
  1904.   getSourceBufferParams_(contentType) {
  1905.     if (!this.sourceBuffers_[contentType]) {
  1906.       return null;
  1907.     }
  1908.     return {
  1909.       timestampOffset: this.sourceBuffers_[contentType].timestampOffset,
  1910.       appendWindowStart: this.sourceBuffers_[contentType].appendWindowStart,
  1911.       appendWindowEnd: this.sourceBuffers_[contentType].appendWindowEnd,
  1912.     };
  1913.   }
  1915.   /**
  1916.    * Restore source buffer parameters
  1917.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1918.    * @param {?shaka.media.MediaSourceEngine.SourceBufferParams} params
  1919.    * @private
  1920.    */
  1921.   restoreSourceBufferParams_(contentType, params) {
  1922.     if (!params) {
  1923.       return;
  1924.     }
  1926.     if (!this.sourceBuffers_[contentType]) {
  1927.       shaka.log.warning('Attempted to restore a non-existent source buffer');
  1928.       return;
  1929.     }
  1931.     this.sourceBuffers_[contentType].timestampOffset =
  1932.       params.timestampOffset;
  1933.     // `end` needs to be set before `start`
  1934.     this.sourceBuffers_[contentType].appendWindowEnd =
  1935.       params.appendWindowEnd;
  1936.     this.sourceBuffers_[contentType].appendWindowStart =
  1937.       params.appendWindowStart;
  1938.   }
  1940.   /**
  1941.    * Resets the MediaSource and re-adds source buffers due to codec mismatch
  1942.    *
  1943.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  1944.    *               shaka.extern.Stream>} streamsByType
  1945.    * @private
  1946.    */
  1947.   async reset_(streamsByType) {
  1948.     const Functional = shaka.util.Functional;
  1949.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1950.     this.reloadingMediaSource_ = true;
  1951.     this.needSplitMuxedContent_ = false;
  1952.     const currentTime = this.video_.currentTime;
  1954.     // When codec switching if the user is currently paused we don't want
  1955.     // to trigger a play when switching codec.
  1956.     // Playing can also end up in a paused state after a codec switch
  1957.     // so we need to remember the current states.
  1958.     const previousAutoPlayState = this.video_.autoplay;
  1959.     const previousPausedState = this.video_.paused;
  1960.     if (this.playbackHasBegun_) {
  1961.       // Only set autoplay to false if the video playback has already begun.
  1962.       // When a codec switch happens before playback has begun this can cause
  1963.       // autoplay not to work as expected.
  1964.       this.video_.autoplay = false;
  1965.     }
  1967.     try {
  1968.       this.eventManager_.removeAll();
  1970.       const cleanup = [];
  1971.       for (const contentType in this.transmuxers_) {
  1972.         cleanup.push(this.transmuxers_[contentType].destroy());
  1973.       }
  1974.       for (const contentType in this.queues_) {
  1975.         // Make a local copy of the queue and the first item.
  1976.         const q = this.queues_[contentType];
  1977.         const inProgress = q[0];
  1979.         // Drop everything else out of the original queue.
  1980.         this.queues_[contentType] = q.slice(0, 1);
  1982.         // We will wait for this item to complete/fail.
  1983.         if (inProgress) {
  1984.           cleanup.push(inProgress.p.catch(Functional.noop));
  1985.         }
  1987.         // The rest will be rejected silently if possible.
  1988.         for (const item of q.slice(1)) {
  1989.           item.p.reject(shaka.util.Destroyer.destroyedError());
  1990.         }
  1991.       }
  1992.       for (const contentType in this.sourceBuffers_) {
  1993.         const sourceBuffer = this.sourceBuffers_[contentType];
  1994.         try {
  1995.           this.mediaSource_.removeSourceBuffer(sourceBuffer);
  1996.         } catch (e) {}
  1997.       }
  1998.       await Promise.all(cleanup);
  1999.       this.transmuxers_ = {};
  2001.       const previousDuration = this.mediaSource_.duration;
  2002.       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
  2003.       this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
  2004.       await this.mediaSourceOpen_;
  2005.       if (!isNaN(previousDuration) && previousDuration) {
  2006.         this.mediaSource_.duration = previousDuration;
  2007.       } else if (!isNaN(this.lastDuration_) && this.lastDuration_) {
  2008.         this.mediaSource_.duration = this.lastDuration_;
  2009.       }
  2011.       const sourceBufferAdded = new shaka.util.PublicPromise();
  2012.       const sourceBuffers =
  2013.         /** @type {EventTarget} */(this.mediaSource_.sourceBuffers);
  2015.       const totalOfBuffers = streamsByType.size;
  2016.       let numberOfSourceBufferAdded = 0;
  2017.       const onSourceBufferAdded = () => {
  2018.         numberOfSourceBufferAdded++;
  2019.         if (numberOfSourceBufferAdded === totalOfBuffers) {
  2020.           sourceBufferAdded.resolve();
  2021.           this.eventManager_.unlisten(sourceBuffers, 'addsourcebuffer',
  2022.               onSourceBufferAdded);
  2023.         }
  2024.       };
  2026.       this.eventManager_.listen(sourceBuffers, 'addsourcebuffer',
  2027.           onSourceBufferAdded);
  2029.       for (const contentType of streamsByType.keys()) {
  2030.         const previousParams = this.getSourceBufferParams_(contentType);
  2031.         const stream = streamsByType.get(contentType);
  2032.         // eslint-disable-next-line no-await-in-loop
  2033.         await this.initSourceBuffer_(contentType, stream, stream.codecs);
  2034.         if (this.needSplitMuxedContent_) {
  2035.           this.queues_[ContentType.AUDIO] = [];
  2036.           this.queues_[ContentType.VIDEO] = [];
  2037.         } else {
  2038.           this.queues_[contentType] = [];
  2039.         }
  2041.         this.restoreSourceBufferParams_(contentType, previousParams);
  2042.       }
  2044.       // Fake a seek to catchup the playhead.
  2045.       this.video_.currentTime = currentTime;
  2047.       await sourceBufferAdded;
  2048.     } finally {
  2049.       this.reloadingMediaSource_ = false;
  2051.       this.destroyer_.ensureNotDestroyed();
  2053.       this.eventManager_.listenOnce(this.video_, 'canplaythrough', () => {
  2054.         // Don't use ensureNotDestroyed() from this event listener, because
  2055.         // that results in an uncaught exception.  Instead, just check the
  2056.         // flag.
  2057.         if (this.destroyer_.destroyed()) {
  2058.           return;
  2059.         }
  2061.         this.video_.autoplay = previousAutoPlayState;
  2062.         if (!previousPausedState) {
  2063.           this.video_.play();
  2064.         }
  2065.       });
  2066.     }
  2067.   }
  2069.   /**
  2070.    * Resets the Media Source
  2071.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  2072.    *               shaka.extern.Stream>} streamsByType
  2073.    * @return {!Promise}
  2074.    */
  2075.   reset(streamsByType) {
  2076.     return this.enqueueBlockingOperation_(
  2077.         () => this.reset_(streamsByType));
  2078.   }
  2080.   /**
  2081.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2082.    * @param {string} mimeType
  2083.    * @param {string} codecs
  2084.    * @return {{transmuxer: ?shaka.extern.Transmuxer,
  2085.    *          transmuxerMuxed: boolean, basicType: string, codec: string,
  2086.    *          mimeType: string}}
  2087.    * @private
  2088.    */
  2089.   getRealInfo_(contentType, mimeType, codecs) {
  2090.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2091.     const MimeUtils = shaka.util.MimeUtils;
  2092.     /** @type {?shaka.extern.Transmuxer} */
  2093.     let transmuxer;
  2094.     let transmuxerMuxed = false;
  2095.     const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  2096.         ContentType.AUDIO, (codecs || '').split(','));
  2097.     const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
  2098.         ContentType.VIDEO, (codecs || '').split(','));
  2099.     let codec = videoCodec;
  2100.     if (contentType == ContentType.AUDIO) {
  2101.       codec = audioCodec;
  2102.     }
  2103.     if (!codec) {
  2104.       codec = codecs;
  2105.     }
  2106.     let newMimeType = shaka.util.MimeUtils.getFullType(mimeType, codec);
  2107.     let needTransmux = this.config_.forceTransmux;
  2108.     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
  2109.         (!this.sequenceMode_ &&
  2110.         shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
  2111.       needTransmux = true;
  2112.     }
  2113.     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
  2114.     if (needTransmux) {
  2115.       const newMimeTypeWithAllCodecs =
  2116.           shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codec);
  2117.       const transmuxerPlugin =
  2118.           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
  2119.       if (transmuxerPlugin) {
  2120.         transmuxer = transmuxerPlugin();
  2121.         if (audioCodec && videoCodec) {
  2122.           transmuxerMuxed = true;
  2123.         }
  2124.         newMimeType =
  2125.             transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
  2126.       }
  2127.     }
  2129.     const newCodec = MimeUtils.getNormalizedCodec(
  2130.         MimeUtils.getCodecs(newMimeType));
  2131.     const newBasicType = MimeUtils.getBasicType(newMimeType);
  2132.     return {
  2133.       transmuxer,
  2134.       transmuxerMuxed,
  2135.       basicType: newBasicType,
  2136.       codec: newCodec,
  2137.       mimeType: newMimeType,
  2138.     };
  2139.   }
  2141.   /**
  2142.    * Codec switch if necessary, this will not resolve until the codec
  2143.    * switch is over.
  2144.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2145.    * @param {string} mimeType
  2146.    * @param {string} codecs
  2147.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  2148.    *               shaka.extern.Stream>} streamsByType
  2149.    * @return {!Promise.<boolean>} true if there was a codec switch,
  2150.    *                              false otherwise.
  2151.    * @private
  2152.    */
  2153.   async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
  2154.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2155.     if (contentType == ContentType.TEXT) {
  2156.       return false;
  2157.     }
  2158.     const MimeUtils = shaka.util.MimeUtils;
  2159.     const currentCodec = MimeUtils.getNormalizedCodec(
  2160.         MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
  2161.     const currentBasicType = MimeUtils.getBasicType(
  2162.         this.sourceBufferTypes_[contentType]);
  2164.     const realInfo = this.getRealInfo_(contentType, mimeType, codecs);
  2165.     const transmuxer = realInfo.transmuxer;
  2166.     const transmuxerMuxed = realInfo.transmuxerMuxed;
  2167.     const newBasicType = realInfo.basicType;
  2168.     const newCodec = realInfo.codec;
  2169.     const newMimeType = realInfo.mimeType;
  2171.     let muxedContentCheck = true;
  2172.     if (transmuxerMuxed) {
  2173.       const muxedRealInfo =
  2174.           this.getRealInfo_(ContentType.AUDIO, mimeType, codecs);
  2175.       const muxedCurrentCodec = MimeUtils.getNormalizedCodec(
  2176.           MimeUtils.getCodecs(this.sourceBufferTypes_[ContentType.AUDIO]));
  2177.       const muxedCurrentBasicType = MimeUtils.getBasicType(
  2178.           this.sourceBufferTypes_[ContentType.AUDIO]);
  2179.       muxedContentCheck = muxedCurrentCodec == muxedRealInfo.codec &&
  2180.         muxedCurrentBasicType == muxedRealInfo.basicType;
  2181.       if (muxedRealInfo.transmuxer) {
  2182.         muxedRealInfo.transmuxer.destroy();
  2183.       }
  2184.     }
  2186.     // Current/new codecs base and basic type match then no need to switch
  2187.     if (currentCodec === newCodec && currentBasicType === newBasicType &&
  2188.         muxedContentCheck) {
  2189.       if (this.transmuxers_[contentType] && !transmuxer) {
  2190.         this.transmuxers_[contentType].destroy();
  2191.         delete this.transmuxers_[contentType];
  2192.       } else if (!this.transmuxers_[contentType] && transmuxer) {
  2193.         this.transmuxers_[contentType] = transmuxer;
  2194.       } else if (transmuxer) {
  2195.         // Compare if the transmuxer is different
  2196.         if (this.transmuxers_[contentType] &&
  2197.             this.transmuxers_[contentType].transmux != transmuxer.transmux) {
  2198.           this.transmuxers_[contentType].destroy();
  2199.           delete this.transmuxers_[contentType];
  2200.           this.transmuxers_[contentType] = transmuxer;
  2201.         } else {
  2202.           transmuxer.destroy();
  2203.         }
  2204.       }
  2205.       return false;
  2206.     }
  2208.     let allowChangeType = true;
  2209.     if (this.needSplitMuxedContent_ || (transmuxerMuxed &&
  2210.         transmuxer && !this.transmuxers_[contentType])) {
  2211.       allowChangeType = false;
  2212.     }
  2214.     if (allowChangeType && this.config_.codecSwitchingStrategy ===
  2215.         shaka.config.CodecSwitchingStrategy.SMOOTH &&
  2216.           shaka.media.Capabilities.isChangeTypeSupported()) {
  2217.       await this.changeType(contentType, newMimeType, transmuxer);
  2218.     } else {
  2219.       if (transmuxer) {
  2220.         transmuxer.destroy();
  2221.       }
  2222.       await this.reset(streamsByType);
  2223.     }
  2224.     return true;
  2225.   }
  2227.   /**
  2228.    * Returns true if it's necessary codec switch to load the new stream.
  2229.    *
  2230.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2231.    * @param {shaka.extern.Stream} stream
  2232.    * @param {string} refMimeType
  2233.    * @param {string} refCodecs
  2234.    * @return {boolean}
  2235.    * @private
  2236.    */
  2237.   isCodecSwitchNecessary_(contentType, stream, refMimeType, refCodecs) {
  2238.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  2239.       return false;
  2240.     }
  2241.     const MimeUtils = shaka.util.MimeUtils;
  2242.     const currentCodec = MimeUtils.getNormalizedCodec(
  2243.         MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
  2244.     const currentBasicType = MimeUtils.getBasicType(
  2245.         this.sourceBufferTypes_[contentType]);
  2247.     let newMimeType = shaka.util.MimeUtils.getFullType(refMimeType, refCodecs);
  2248.     let needTransmux = this.config_.forceTransmux;
  2249.     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
  2250.         (!this.sequenceMode_ &&
  2251.         shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
  2252.       needTransmux = true;
  2253.     }
  2254.     const newMimeTypeWithAllCodecs =
  2255.         shaka.util.MimeUtils.getFullTypeWithAllCodecs(
  2256.             refMimeType, refCodecs);
  2257.     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
  2258.     if (needTransmux) {
  2259.       const transmuxerPlugin =
  2260.           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
  2261.       if (transmuxerPlugin) {
  2262.         const transmuxer = transmuxerPlugin();
  2263.         newMimeType =
  2264.             transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
  2265.         transmuxer.destroy();
  2266.       }
  2267.     }
  2269.     const newCodec = MimeUtils.getNormalizedCodec(
  2270.         MimeUtils.getCodecs(newMimeType));
  2271.     const newBasicType = MimeUtils.getBasicType(newMimeType);
  2273.     return currentCodec !== newCodec || currentBasicType !== newBasicType;
  2274.   }
  2276.   /**
  2277.    * Returns true if it's necessary reset the media source to load the
  2278.    * new stream.
  2279.    *
  2280.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  2281.    * @param {shaka.extern.Stream} stream
  2282.    * @param {string} mimeType
  2283.    * @param {string} codecs
  2284.    * @return {boolean}
  2285.    */
  2286.   isResetMediaSourceNecessary(contentType, stream, mimeType, codecs) {
  2287.     if (!this.isCodecSwitchNecessary_(contentType, stream, mimeType, codecs)) {
  2288.       return false;
  2289.     }
  2291.     return this.config_.codecSwitchingStrategy !==
  2292.         shaka.config.CodecSwitchingStrategy.SMOOTH ||
  2293.         !shaka.media.Capabilities.isChangeTypeSupported() ||
  2294.         this.needSplitMuxedContent_;
  2295.   }
  2297.   /**
  2298.    * Update LCEVC Decoder object when ready for LCEVC Decode.
  2299.    * @param {?shaka.lcevc.Dec} lcevcDec
  2300.    */
  2301.   updateLcevcDec(lcevcDec) {
  2302.     this.lcevcDec_ = lcevcDec;
  2303.   }
  2305.   /**
  2306.    * @param {string} mimeType
  2307.    * @return {string}
  2308.    * @private
  2309.    */
  2310.   addExtraFeaturesToMimeType_(mimeType) {
  2311.     const extraFeatures = this.config_.addExtraFeaturesToSourceBuffer(mimeType);
  2312.     const extendedType = mimeType + extraFeatures;
  2313.     shaka.log.debug('Using full mime type', extendedType);
  2315.     return extendedType;
  2316.   }
  2317. };
  2320. /**
  2321.  * Internal reference to window.URL.createObjectURL function to avoid
  2322.  * compatibility issues with other libraries and frameworks such as React
  2323.  * Native. For use in unit tests only, not meant for external use.
  2324.  *
  2325.  * @type {function(?):string}
  2326.  */
  2327. shaka.media.MediaSourceEngine.createObjectURL = window.URL.createObjectURL;
  2330. /**
  2331.  * @typedef {{
  2332.  *   start: function(),
  2333.  *   p: !shaka.util.PublicPromise,
  2334.  *   uri: ?string
  2335.  * }}
  2336.  *
  2337.  * @summary An operation in queue.
  2338.  * @property {function()} start
  2339.  *   The function which starts the operation.
  2340.  * @property {!shaka.util.PublicPromise} p
  2341.  *   The PublicPromise which is associated with this operation.
  2342.  * @property {?string} uri
  2343.  *   A segment URI (if any) associated with this operation.
  2344.  */
  2345. shaka.media.MediaSourceEngine.Operation;
  2348. /**
  2349.  * @enum {string}
  2350.  * @private
  2351.  */
  2352. shaka.media.MediaSourceEngine.SourceBufferMode_ = {
  2353.   SEQUENCE: 'sequence',
  2354.   SEGMENTS: 'segments',
  2355. };
  2358. /**
  2359.  * @typedef {{
  2360.  *   getKeySystem: function():?string,
  2361.  *   onMetadata: function(!Array<shaka.extern.ID3Metadata>, number, ?number)
  2362.  * }}
  2363.  *
  2364.  * @summary Player interface
  2365.  * @property {function():?string} getKeySystem
  2366.  *   Gets currently used key system or null if not used.
  2367.  * @property {function(
  2368.  *     !Array<shaka.extern.ID3Metadata>, number, ?number)} onMetadata
  2369.  *   Callback to use when metadata arrives.
  2370.  */
  2371. shaka.media.MediaSourceEngine.PlayerInterface;
  2373. /**
  2374.  * @typedef {{
  2375.  *   timestampOffset: number,
  2376.  *   appendWindowStart: number,
  2377.  *   appendWindowEnd: number
  2378.  * }}
  2379.  */
  2380. shaka.media.MediaSourceEngine.SourceBufferParams;