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