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.media.ContentWorkarounds');
  12. goog.require('shaka.media.IClosedCaptionParser');
  13. goog.require('shaka.media.TimeRangesUtils');
  14. goog.require('shaka.media.Transmuxer');
  15. goog.require('shaka.text.TextEngine');
  16. goog.require('shaka.util.Destroyer');
  17. goog.require('shaka.util.Error');
  18. goog.require('shaka.util.EventManager');
  19. goog.require('shaka.util.Functional');
  20. goog.require('shaka.util.IDestroyable');
  21. goog.require('shaka.util.ManifestParserUtils');
  22. goog.require('shaka.util.MimeUtils');
  23. goog.require('shaka.util.Platform');
  24. goog.require('shaka.util.PublicPromise');
  27. /**
  28.  * @summary
  29.  * MediaSourceEngine wraps all operations on MediaSource and SourceBuffers.
  30.  * All asynchronous operations return a Promise, and all operations are
  31.  * internally synchronized and serialized as needed.  Operations that can
  32.  * be done in parallel will be done in parallel.
  33.  *
  34.  * @implements {shaka.util.IDestroyable}
  35.  */
  36. shaka.media.MediaSourceEngine = class {
  37.   /**
  38.    * @param {HTMLMediaElement} video The video element, whose source is tied to
  39.    *   MediaSource during the lifetime of the MediaSourceEngine.
  40.    * @param {!shaka.media.IClosedCaptionParser} closedCaptionParser
  41.    *    The closed caption parser that should be used to parser closed captions
  42.    *    from the video stream. MediaSourceEngine takes ownership of the parser.
  43.    *    When MediaSourceEngine is destroyed, it will destroy the parser.
  44.    * @param {!shaka.extern.TextDisplayer} textDisplayer
  45.    *    The text displayer that will be used with the text engine.
  46.    *    MediaSourceEngine takes ownership of the displayer. When
  47.    *    MediaSourceEngine is destroyed, it will destroy the displayer.
  48.    * @param {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)=}
  49.    *    onMetadata
  50.    */
  51.   constructor(video, closedCaptionParser, textDisplayer, onMetadata) {
  52.     /** @private {HTMLMediaElement} */
  53.     this.video_ = video;
  55.     /** @private {shaka.extern.TextDisplayer} */
  56.     this.textDisplayer_ = textDisplayer;
  58.     /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  59.                            SourceBuffer>} */
  60.     this.sourceBuffers_ = {};
  62.     /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  63.                            string>} */
  64.     this.sourceBufferTypes_ = {};
  67.     /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
  68.                            boolean>} */
  69.     this.expectedEncryption_ = {};
  71.     /** @private {shaka.text.TextEngine} */
  72.     this.textEngine_ = null;
  74.     const onMetadataNoOp = (metadata, timestampOffset, segmentEnd) => {};
  76.     /** @private {!function(!Array.<shaka.extern.ID3Metadata>,
  77.                     number, ?number)} */
  78.     this.onMetadata_ = onMetadata || onMetadataNoOp;
  80.     /**
  81.      * @private {!Object.<string,
  82.      *                    !Array.<shaka.media.MediaSourceEngine.Operation>>}
  83.      */
  84.     this.queues_ = {};
  86.     /** @private {shaka.util.EventManager} */
  87.     this.eventManager_ = new shaka.util.EventManager();
  89.     /** @private {!Object.<string, !shaka.media.Transmuxer>} */
  90.     this.transmuxers_ = {};
  92.     /** @private {shaka.media.IClosedCaptionParser} */
  93.     this.captionParser_ = closedCaptionParser;
  95.     /** @private {!shaka.util.PublicPromise} */
  96.     this.mediaSourceOpen_ = new shaka.util.PublicPromise();
  98.     /** @private {MediaSource} */
  99.     this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
  101.     /** @type {!shaka.util.Destroyer} */
  102.     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
  104.     /** @private {string} */
  105.     this.url_ = '';
  106.   }
  108.   /**
  109.    * Create a MediaSource object, attach it to the video element, and return it.
  110.    * Resolves the given promise when the MediaSource is ready.
  111.    *
  112.    * Replaced by unit tests.
  113.    *
  114.    * @param {!shaka.util.PublicPromise} p
  115.    * @return {!MediaSource}
  116.    */
  117.   createMediaSource(p) {
  118.     const mediaSource = new MediaSource();
  120.     // Set up MediaSource on the video element.
  121.     this.eventManager_.listenOnce(
  122.         mediaSource, 'sourceopen', () => this.onSourceOpen_(p));
  124.     // Store the object URL for releasing it later.
  125.     this.url_ = shaka.media.MediaSourceEngine.createObjectURL(mediaSource);
  127.     this.video_.src = this.url_;
  129.     return mediaSource;
  130.   }
  132.   /**
  133.    * @param {!shaka.util.PublicPromise} p
  134.    * @private
  135.    */
  136.   onSourceOpen_(p) {
  137.     // Release the object URL that was previously created, to prevent memory
  138.     // leak.
  139.     // createObjectURL creates a strong reference to the MediaSource object
  140.     // inside the browser.  Setting the src of the video then creates another
  141.     // reference within the video element.  revokeObjectURL will remove the
  142.     // strong reference to the MediaSource object, and allow it to be
  143.     // garbage-collected later.
  144.     URL.revokeObjectURL(this.url_);
  145.     p.resolve();
  146.   }
  148.   /**
  149.    * Checks if a certain type is supported.
  150.    *
  151.    * @param {shaka.extern.Stream} stream
  152.    * @return {boolean}
  153.    */
  154.   static isStreamSupported(stream) {
  155.     const fullMimeType = shaka.util.MimeUtils.getFullType(
  156.         stream.mimeType, stream.codecs);
  157.     const extendedMimeType = shaka.util.MimeUtils.getExtendedType(stream);
  158.     return shaka.text.TextEngine.isTypeSupported(fullMimeType) ||
  159.         MediaSource.isTypeSupported(extendedMimeType) ||
  160.         shaka.media.Transmuxer.isSupported(fullMimeType, stream.type);
  161.   }
  163.   /**
  164.    * Returns a map of MediaSource support for well-known types.
  165.    *
  166.    * @return {!Object.<string, boolean>}
  167.    */
  168.   static probeSupport() {
  169.     const testMimeTypes = [
  170.       // MP4 types
  171.       'video/mp4; codecs="avc1.42E01E"',
  172.       'video/mp4; codecs="avc3.42E01E"',
  173.       'video/mp4; codecs="hev1.1.6.L93.90"',
  174.       'video/mp4; codecs="hvc1.1.6.L93.90"',
  175.       'video/mp4; codecs="hev1.2.4.L153.B0"; eotf="smpte2084"',  // HDR HEVC
  176.       'video/mp4; codecs="hvc1.2.4.L153.B0"; eotf="smpte2084"',  // HDR HEVC
  177.       'video/mp4; codecs="vp9"',
  178.       'video/mp4; codecs="vp09.00.10.08"',
  179.       'video/mp4; codecs="av01.0.01M.08"',
  180.       'audio/mp4; codecs="mp4a.40.2"',
  181.       'audio/mp4; codecs="ac-3"',
  182.       'audio/mp4; codecs="ec-3"',
  183.       'audio/mp4; codecs="opus"',
  184.       'audio/mp4; codecs="flac"',
  185.       'audio/mp4; codecs="dtsc"', // DTS Digital Surround
  186.       'audio/mp4; codecs="dtse"', // DTS Express
  187.       'audio/mp4; codecs="dtsx"', // DTS:X
  188.       // WebM types
  189.       'video/webm; codecs="vp8"',
  190.       'video/webm; codecs="vp9"',
  191.       'video/webm; codecs="vp09.00.10.08"',
  192.       'audio/webm; codecs="vorbis"',
  193.       'audio/webm; codecs="opus"',
  194.       // MPEG2 TS types (video/ is also used for audio: https://bit.ly/TsMse)
  195.       'video/mp2t; codecs="avc1.42E01E"',
  196.       'video/mp2t; codecs="avc3.42E01E"',
  197.       'video/mp2t; codecs="hvc1.1.6.L93.90"',
  198.       'video/mp2t; codecs="mp4a.40.2"',
  199.       'video/mp2t; codecs="ac-3"',
  200.       'video/mp2t; codecs="ec-3"',
  201.       // WebVTT types
  202.       'text/vtt',
  203.       'application/mp4; codecs="wvtt"',
  204.       // TTML types
  205.       'application/ttml+xml',
  206.       'application/mp4; codecs="stpp"',
  207.     ];
  209.     const support = {};
  210.     for (const type of testMimeTypes) {
  211.       if (shaka.util.Platform.supportsMediaSource()) {
  212.         // Our TextEngine is only effective for MSE platforms at the moment.
  213.         if (shaka.text.TextEngine.isTypeSupported(type)) {
  214.           support[type] = true;
  215.         } else {
  216.           support[type] = MediaSource.isTypeSupported(type) ||
  217.                           shaka.media.Transmuxer.isSupported(type);
  218.         }
  219.       } else {
  220.         support[type] = shaka.util.Platform.supportsMediaType(type);
  221.       }
  223.       const basicType = type.split(';')[0];
  224.       support[basicType] = support[basicType] || support[type];
  225.     }
  227.     return support;
  228.   }
  230.   /** @override */
  231.   destroy() {
  232.     return this.destroyer_.destroy();
  233.   }
  235.   /** @private */
  236.   async doDestroy_() {
  237.     const Functional = shaka.util.Functional;
  239.     const cleanup = [];
  241.     for (const contentType in this.queues_) {
  242.       // Make a local copy of the queue and the first item.
  243.       const q = this.queues_[contentType];
  244.       const inProgress = q[0];
  246.       // Drop everything else out of the original queue.
  247.       this.queues_[contentType] = q.slice(0, 1);
  249.       // We will wait for this item to complete/fail.
  250.       if (inProgress) {
  251.         cleanup.push(inProgress.p.catch(Functional.noop));
  252.       }
  254.       // The rest will be rejected silently if possible.
  255.       for (const item of q.slice(1)) {
  256.         item.p.reject(shaka.util.Destroyer.destroyedError());
  257.       }
  258.     }
  260.     if (this.textEngine_) {
  261.       cleanup.push(this.textEngine_.destroy());
  262.     }
  263.     if (this.textDisplayer_) {
  264.       cleanup.push(this.textDisplayer_.destroy());
  265.     }
  267.     for (const contentType in this.transmuxers_) {
  268.       cleanup.push(this.transmuxers_[contentType].destroy());
  269.     }
  272.     await Promise.all(cleanup);
  273.     if (this.eventManager_) {
  274.       this.eventManager_.release();
  275.       this.eventManager_ = null;
  276.     }
  278.     if (this.video_) {
  279.       // "unload" the video element.
  280.       this.video_.removeAttribute('src');
  281.       this.video_.load();
  282.       this.video_ = null;
  283.     }
  285.     this.mediaSource_ = null;
  286.     this.textEngine_ = null;
  287.     this.textDisplayer_ = null;
  288.     this.sourceBuffers_ = {};
  289.     this.transmuxers_ = {};
  290.     this.captionParser_ = null;
  291.     if (goog.DEBUG) {
  292.       for (const contentType in this.queues_) {
  293.         goog.asserts.assert(
  294.             this.queues_[contentType].length == 0,
  295.             contentType + ' queue should be empty after destroy!');
  296.       }
  297.     }
  298.     this.queues_ = {};
  299.   }
  301.   /**
  302.    * @return {!Promise} Resolved when MediaSource is open and attached to the
  303.    *   media element.  This process is actually initiated by the constructor.
  304.    */
  305.   open() {
  306.     return this.mediaSourceOpen_;
  307.   }
  309.   /**
  310.    * Initialize MediaSourceEngine.
  311.    *
  312.    * Note that it is not valid to call this multiple times, except to add or
  313.    * reinitialize text streams.
  314.    *
  315.    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
  316.    *               shaka.extern.Stream>} streamsByType
  317.    *   A map of content types to streams.  All streams must be supported
  318.    *   according to MediaSourceEngine.isStreamSupported.
  319.    * @param {boolean} forceTransmuxTS
  320.    *   If true, this will transmux TS content even if it is natively supported.
  321.    *
  322.    * @return {!Promise}
  323.    */
  324.   async init(streamsByType, forceTransmuxTS) {
  325.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  327.     await this.mediaSourceOpen_;
  329.     for (const contentType of streamsByType.keys()) {
  330.       const stream = streamsByType.get(contentType);
  331.       goog.asserts.assert(
  332.           shaka.media.MediaSourceEngine.isStreamSupported(stream),
  333.           'Type negotiation should happen before MediaSourceEngine.init!');
  335.       let mimeType = shaka.util.MimeUtils.getFullType(
  336.           stream.mimeType, stream.codecs);
  337.       if (contentType == ContentType.TEXT) {
  338.         this.reinitText(mimeType);
  339.       } else {
  340.         if ((forceTransmuxTS || !MediaSource.isTypeSupported(mimeType)) &&
  341.             shaka.media.Transmuxer.isSupported(mimeType, contentType)) {
  342.           this.transmuxers_[contentType] = new shaka.media.Transmuxer();
  343.           mimeType =
  344.               shaka.media.Transmuxer.convertTsCodecs(contentType, mimeType);
  345.         }
  346.         const sourceBuffer = this.mediaSource_.addSourceBuffer(mimeType);
  347.         this.eventManager_.listen(
  348.             sourceBuffer, 'error',
  349.             () => this.onError_(contentType));
  350.         this.eventManager_.listen(
  351.             sourceBuffer, 'updateend',
  352.             () => this.onUpdateEnd_(contentType));
  353.         this.sourceBuffers_[contentType] = sourceBuffer;
  354.         this.sourceBufferTypes_[contentType] = mimeType;
  355.         this.queues_[contentType] = [];
  356.         this.expectedEncryption_[contentType] = !!stream.drmInfos.length;
  357.       }
  358.     }
  359.   }
  361.   /**
  362.    * Reinitialize the TextEngine for a new text type.
  363.    * @param {string} mimeType
  364.    */
  365.   reinitText(mimeType) {
  366.     if (!this.textEngine_) {
  367.       this.textEngine_ = new shaka.text.TextEngine(this.textDisplayer_);
  368.     }
  369.     this.textEngine_.initParser(mimeType);
  370.   }
  372.   /**
  373.    * @return {boolean} True if the MediaSource is in an "ended" state, or if the
  374.    *   object has been destroyed.
  375.    */
  376.   ended() {
  377.     return this.mediaSource_ ? this.mediaSource_.readyState == 'ended' : true;
  378.   }
  380.   /**
  381.    * Gets the first timestamp in buffer for the given content type.
  382.    *
  383.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  384.    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  385.    */
  386.   bufferStart(contentType) {
  387.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  388.     if (contentType == ContentType.TEXT) {
  389.       return this.textEngine_.bufferStart();
  390.     }
  391.     return shaka.media.TimeRangesUtils.bufferStart(
  392.         this.getBuffered_(contentType));
  393.   }
  395.   /**
  396.    * Gets the last timestamp in buffer for the given content type.
  397.    *
  398.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  399.    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
  400.    */
  401.   bufferEnd(contentType) {
  402.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  403.     if (contentType == ContentType.TEXT) {
  404.       return this.textEngine_.bufferEnd();
  405.     }
  406.     return shaka.media.TimeRangesUtils.bufferEnd(
  407.         this.getBuffered_(contentType));
  408.   }
  410.   /**
  411.    * Determines if the given time is inside the buffered range of the given
  412.    * content type.
  413.    *
  414.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  415.    * @param {number} time Playhead time
  416.    * @param {number=} smallGapLimit
  417.    * @return {boolean}
  418.    */
  419.   isBuffered(contentType, time, smallGapLimit) {
  420.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  421.     if (contentType == ContentType.TEXT) {
  422.       return this.textEngine_.isBuffered(time);
  423.     } else {
  424.       const buffered = this.getBuffered_(contentType);
  425.       return shaka.media.TimeRangesUtils.isBuffered(
  426.           buffered, time, smallGapLimit);
  427.     }
  428.   }
  430.   /**
  431.    * Computes how far ahead of the given timestamp is buffered for the given
  432.    * content type.
  433.    *
  434.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  435.    * @param {number} time
  436.    * @return {number} The amount of time buffered ahead in seconds.
  437.    */
  438.   bufferedAheadOf(contentType, time) {
  439.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  440.     if (contentType == ContentType.TEXT) {
  441.       return this.textEngine_.bufferedAheadOf(time);
  442.     } else {
  443.       const buffered = this.getBuffered_(contentType);
  444.       return shaka.media.TimeRangesUtils.bufferedAheadOf(buffered, time);
  445.     }
  446.   }
  448.   /**
  449.    * Returns info about what is currently buffered.
  450.    * @return {shaka.extern.BufferedInfo}
  451.    */
  452.   getBufferedInfo() {
  453.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  454.     const TimeRangeUtils = shaka.media.TimeRangesUtils;
  456.     const info = {
  457.       total: TimeRangeUtils.getBufferedInfo(this.video_.buffered),
  458.       audio: TimeRangeUtils.getBufferedInfo(
  459.           this.getBuffered_(ContentType.AUDIO)),
  460.       video: TimeRangeUtils.getBufferedInfo(
  461.           this.getBuffered_(ContentType.VIDEO)),
  462.       text: [],
  463.     };
  465.     if (this.textEngine_) {
  466.       const start = this.textEngine_.bufferStart();
  467.       const end = this.textEngine_.bufferEnd();
  469.       if (start != null && end != null) {
  470.         info.text.push({start: start, end: end});
  471.       }
  472.     }
  473.     return info;
  474.   }
  476.   /**
  477.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  478.    * @return {TimeRanges} The buffered ranges for the given content type, or
  479.    *   null if the buffered ranges could not be obtained.
  480.    * @private
  481.    */
  482.   getBuffered_(contentType) {
  483.     try {
  484.       return this.sourceBuffers_[contentType].buffered;
  485.     } catch (exception) {
  486.       if (contentType in this.sourceBuffers_) {
  487.         // Note: previous MediaSource errors may cause access to |buffered| to
  488.         // throw.
  489.         shaka.log.error('failed to get buffered range for ' + contentType,
  490.             exception);
  491.       }
  492.       return null;
  493.     }
  494.   }
  496.   /**
  497.    * Enqueue an operation to append data to the SourceBuffer.
  498.    * Start and end times are needed for TextEngine, but not for MediaSource.
  499.    * Start and end times may be null for initialization segments; if present
  500.    * they are relative to the presentation timeline.
  501.    *
  502.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  503.    * @param {!BufferSource} data
  504.    * @param {?number} startTime relative to the start of the presentation
  505.    * @param {?number} endTime relative to the start of the presentation
  506.    * @param {?boolean} hasClosedCaptions True if the buffer contains CEA closed
  507.    * captions
  508.    * @return {!Promise}
  509.    */
  510.   async appendBuffer(contentType, data, startTime, endTime, hasClosedCaptions) {
  511.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  513.     if (contentType == ContentType.TEXT) {
  514.       await this.textEngine_.appendBuffer(data, startTime, endTime);
  515.     } else if (this.transmuxers_[contentType]) {
  516.       const transmuxedData =
  517.           await this.transmuxers_[contentType].transmux(data);
  518.       // For HLS CEA-608/708 CLOSED-CAPTIONS, text data is embedded in
  519.       // the video stream, so textEngine may not have been initialized.
  520.       if (!this.textEngine_) {
  521.         this.reinitText(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE);
  522.       }
  524.       if (transmuxedData.metadata) {
  525.         const timestampOffset =
  526.             this.sourceBuffers_[contentType].timestampOffset;
  527.         this.onMetadata_(transmuxedData.metadata, timestampOffset, endTime);
  528.       }
  529.       // This doesn't work for native TS support (ex. Edge/Chromecast),
  530.       // since no transmuxing is needed for native TS.
  531.       if (transmuxedData.captions && transmuxedData.captions.length) {
  532.         const videoOffset =
  533.         this.sourceBuffers_[ContentType.VIDEO].timestampOffset;
  534.         const closedCaptions = this.textEngine_
  535.             .convertMuxjsCaptionsToShakaCaptions(transmuxedData.captions);
  536.         this.textEngine_.storeAndAppendClosedCaptions(
  537.             closedCaptions, startTime, endTime, videoOffset);
  538.       }
  540.       let transmuxedSegment = transmuxedData.data;
  541.       transmuxedSegment = this.workAroundBrokenPlatforms_(
  542.           transmuxedSegment, startTime, contentType);
  544.       await this.enqueueOperation_(
  545.           contentType, () => this.append_(contentType, transmuxedSegment));
  546.     } else if (hasClosedCaptions) {
  547.       if (!this.textEngine_) {
  548.         this.reinitText(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE);
  549.       }
  550.       // If it is the init segment for closed captions, initialize the closed
  551.       // caption parser.
  552.       if (startTime == null && endTime == null) {
  553.         this.captionParser_.init(data);
  554.       } else {
  555.         const closedCaptions = this.captionParser_.parseFrom(data);
  556.         if (closedCaptions.length) {
  557.           const videoOffset =
  558.             this.sourceBuffers_[ContentType.VIDEO].timestampOffset;
  559.           this.textEngine_.storeAndAppendClosedCaptions(
  560.               closedCaptions, startTime, endTime, videoOffset);
  561.         }
  562.       }
  564.       data = this.workAroundBrokenPlatforms_(data, startTime, contentType);
  566.       await this.enqueueOperation_(
  567.           contentType,
  568.           () => this.append_(contentType, data));
  569.     } else {
  570.       data = this.workAroundBrokenPlatforms_(data, startTime, contentType);
  572.       await this.enqueueOperation_(
  573.           contentType,
  574.           () => this.append_(contentType, data));
  575.     }
  576.   }
  578.   /**
  579.    * Set the selected closed captions Id and language.
  580.    *
  581.    * @param {string} id
  582.    */
  583.   setSelectedClosedCaptionId(id) {
  584.     const VIDEO = shaka.util.ManifestParserUtils.ContentType.VIDEO;
  585.     const videoBufferEndTime = this.bufferEnd(VIDEO) || 0;
  586.     this.textEngine_.setSelectedClosedCaptionId(id, videoBufferEndTime);
  587.   }
  589.   /** Disable embedded closed captions. */
  590.   clearSelectedClosedCaptionId() {
  591.     if (this.textEngine_) {
  592.       this.textEngine_.setSelectedClosedCaptionId('', 0);
  593.     }
  594.   }
  596.   /**
  597.    * Enqueue an operation to remove data from the SourceBuffer.
  598.    *
  599.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  600.    * @param {number} startTime relative to the start of the presentation
  601.    * @param {number} endTime relative to the start of the presentation
  602.    * @return {!Promise}
  603.    */
  604.   async remove(contentType, startTime, endTime) {
  605.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  606.     if (contentType == ContentType.TEXT) {
  607.       await this.textEngine_.remove(startTime, endTime);
  608.     } else {
  609.       await this.enqueueOperation_(
  610.           contentType,
  611.           () => this.remove_(contentType, startTime, endTime));
  612.     }
  613.   }
  615.   /**
  616.    * Enqueue an operation to clear the SourceBuffer.
  617.    *
  618.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  619.    * @return {!Promise}
  620.    */
  621.   async clear(contentType) {
  622.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  623.     if (contentType == ContentType.TEXT) {
  624.       if (!this.textEngine_) {
  625.         return;
  626.       }
  627.       await this.textEngine_.remove(0, Infinity);
  628.     } else {
  629.       // Note that not all platforms allow clearing to Infinity.
  630.       await this.enqueueOperation_(
  631.           contentType,
  632.           () => this.remove_(contentType, 0, this.mediaSource_.duration));
  633.     }
  634.   }
  636.   /**
  637.    * Fully reset the state of the caption parser owned by MediaSourceEngine.
  638.    */
  639.   resetCaptionParser() {
  640.     this.captionParser_.reset();
  641.   }
  643.   /**
  644.    * Enqueue an operation to flush the SourceBuffer.
  645.    * This is a workaround for what we believe is a Chromecast bug.
  646.    *
  647.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  648.    * @return {!Promise}
  649.    */
  650.   async flush(contentType) {
  651.     // Flush the pipeline.  Necessary on Chromecast, even though we have removed
  652.     // everything.
  653.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  654.     if (contentType == ContentType.TEXT) {
  655.       // Nothing to flush for text.
  656.       return;
  657.     }
  658.     await this.enqueueOperation_(
  659.         contentType,
  660.         () => this.flush_(contentType));
  661.   }
  663.   /**
  664.    * Sets the timestamp offset and append window end for the given content type.
  665.    *
  666.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  667.    * @param {number} timestampOffset The timestamp offset.  Segments which start
  668.    *   at time t will be inserted at time t + timestampOffset instead.  This
  669.    *   value does not affect segments which have already been inserted.
  670.    * @param {number} appendWindowStart The timestamp to set the append window
  671.    *   start to.  For future appends, frames/samples with timestamps less than
  672.    *   this value will be dropped.
  673.    * @param {number} appendWindowEnd The timestamp to set the append window end
  674.    *   to.  For future appends, frames/samples with timestamps greater than this
  675.    *   value will be dropped.
  676.    * @return {!Promise}
  677.    */
  678.   async setStreamProperties(
  679.       contentType, timestampOffset, appendWindowStart, appendWindowEnd) {
  680.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  681.     if (contentType == ContentType.TEXT) {
  682.       this.textEngine_.setTimestampOffset(timestampOffset);
  683.       this.textEngine_.setAppendWindow(appendWindowStart, appendWindowEnd);
  684.       return;
  685.     }
  687.     await Promise.all([
  688.       // Queue an abort() to help MSE splice together overlapping segments.
  689.       // We set appendWindowEnd when we change periods in DASH content, and the
  690.       // period transition may result in overlap.
  691.       //
  692.       // An abort() also helps with MPEG2-TS.  When we append a TS segment, we
  693.       // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
  694.       // timestamp offset.  By calling abort(), we reset the state so we can
  695.       // set it.
  696.       this.enqueueOperation_(
  697.           contentType,
  698.           () => this.abort_(contentType)),
  699.       this.enqueueOperation_(
  700.           contentType,
  701.           () => this.setTimestampOffset_(contentType, timestampOffset)),
  702.       this.enqueueOperation_(
  703.           contentType,
  704.           () => this.setAppendWindow_(
  705.               contentType, appendWindowStart, appendWindowEnd)),
  706.     ]);
  707.   }
  709.   /**
  710.    * @param {string=} reason Valid reasons are 'network' and 'decode'.
  711.    * @return {!Promise}
  712.    * @see http://w3c.github.io/media-source/#idl-def-EndOfStreamError
  713.    */
  714.   async endOfStream(reason) {
  715.     await this.enqueueBlockingOperation_(() => {
  716.       // If endOfStream() has already been called on the media source,
  717.       // don't call it again. Also do not call if readyState is
  718.       // 'closed' (not attached to video element) since it is not a
  719.       // valid operation.
  720.       if (this.ended() || this.mediaSource_.readyState === 'closed') {
  721.         return;
  722.       }
  723.       // Tizen won't let us pass undefined, but it will let us omit the
  724.       // argument.
  725.       if (reason) {
  726.         this.mediaSource_.endOfStream(reason);
  727.       } else {
  728.         this.mediaSource_.endOfStream();
  729.       }
  730.     });
  731.   }
  733.   /**
  734.    * We only support increasing duration at this time.  Decreasing duration
  735.    * causes the MSE removal algorithm to run, which results in an 'updateend'
  736.    * event.  Supporting this scenario would be complicated, and is not currently
  737.    * needed.
  738.    *
  739.    * @param {number} duration
  740.    * @return {!Promise}
  741.    */
  742.   async setDuration(duration) {
  743.     goog.asserts.assert(
  744.         isNaN(this.mediaSource_.duration) ||
  745.             this.mediaSource_.duration <= duration,
  746.         'duration cannot decrease: ' + this.mediaSource_.duration + ' -> ' +
  747.             duration);
  748.     await this.enqueueBlockingOperation_(() => {
  749.       this.mediaSource_.duration = duration;
  750.     });
  751.   }
  753.   /**
  754.    * Get the current MediaSource duration.
  755.    *
  756.    * @return {number}
  757.    */
  758.   getDuration() {
  759.     return this.mediaSource_.duration;
  760.   }
  762.   /**
  763.    * Append data to the SourceBuffer.
  764.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  765.    * @param {BufferSource} data
  766.    * @private
  767.    */
  768.   append_(contentType, data) {
  769.     // This will trigger an 'updateend' event.
  770.     this.sourceBuffers_[contentType].appendBuffer(data);
  771.   }
  773.   /**
  774.    * Remove data from the SourceBuffer.
  775.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  776.    * @param {number} startTime relative to the start of the presentation
  777.    * @param {number} endTime relative to the start of the presentation
  778.    * @private
  779.    */
  780.   remove_(contentType, startTime, endTime) {
  781.     if (endTime <= startTime) {
  782.       // Ignore removal of inverted or empty ranges.
  783.       // Fake 'updateend' event to resolve the operation.
  784.       this.onUpdateEnd_(contentType);
  785.       return;
  786.     }
  788.     // This will trigger an 'updateend' event.
  789.     this.sourceBuffers_[contentType].remove(startTime, endTime);
  790.   }
  792.   /**
  793.    * Call abort() on the SourceBuffer.
  794.    * This resets MSE's last_decode_timestamp on all track buffers, which should
  795.    * trigger the splicing logic for overlapping segments.
  796.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  797.    * @private
  798.    */
  799.   abort_(contentType) {
  800.     // Save the append window, which is reset on abort().
  801.     const appendWindowStart =
  802.         this.sourceBuffers_[contentType].appendWindowStart;
  803.     const appendWindowEnd = this.sourceBuffers_[contentType].appendWindowEnd;
  805.     // This will not trigger an 'updateend' event, since nothing is happening.
  806.     // This is only to reset MSE internals, not to abort an actual operation.
  807.     this.sourceBuffers_[contentType].abort();
  809.     // Restore the append window.
  810.     this.sourceBuffers_[contentType].appendWindowStart = appendWindowStart;
  811.     this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
  813.     // Fake an 'updateend' event to resolve the operation.
  814.     this.onUpdateEnd_(contentType);
  815.   }
  817.   /**
  818.    * Nudge the playhead to force the media pipeline to be flushed.
  819.    * This seems to be necessary on Chromecast to get new content to replace old
  820.    * content.
  821.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  822.    * @private
  823.    */
  824.   flush_(contentType) {
  825.     // Never use flush_ if there's data.  It causes a hiccup in playback.
  826.     goog.asserts.assert(
  827.         this.video_.buffered.length == 0, 'MediaSourceEngine.flush_ should ' +
  828.         'only be used after clearing all data!');
  830.     // Seeking forces the pipeline to be flushed.
  831.     this.video_.currentTime -= 0.001;
  833.     // Fake an 'updateend' event to resolve the operation.
  834.     this.onUpdateEnd_(contentType);
  835.   }
  837.   /**
  838.    * Set the SourceBuffer's timestamp offset.
  839.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  840.    * @param {number} timestampOffset
  841.    * @private
  842.    */
  843.   setTimestampOffset_(contentType, timestampOffset) {
  844.     // Work around for
  845.     // https://github.com/shaka-project/shaka-player/issues/1281:
  846.     // TODO(https://bit.ly/2ttKiBU): follow up when this is fixed in Edge
  847.     if (timestampOffset < 0) {
  848.       // Try to prevent rounding errors in Edge from removing the first
  849.       // keyframe.
  850.       timestampOffset += 0.001;
  851.     }
  853.     this.sourceBuffers_[contentType].timestampOffset = timestampOffset;
  855.     // Fake an 'updateend' event to resolve the operation.
  856.     this.onUpdateEnd_(contentType);
  857.   }
  859.   /**
  860.    * Set the SourceBuffer's append window end.
  861.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  862.    * @param {number} appendWindowStart
  863.    * @param {number} appendWindowEnd
  864.    * @private
  865.    */
  866.   setAppendWindow_(contentType, appendWindowStart, appendWindowEnd) {
  867.     // You can't set start > end, so first set start to 0, then set the new
  868.     // end, then set the new start.  That way, there are no intermediate
  869.     // states which are invalid.
  870.     this.sourceBuffers_[contentType].appendWindowStart = 0;
  871.     this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
  872.     this.sourceBuffers_[contentType].appendWindowStart = appendWindowStart;
  874.     // Fake an 'updateend' event to resolve the operation.
  875.     this.onUpdateEnd_(contentType);
  876.   }
  878.   /**
  879.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  880.    * @private
  881.    */
  882.   onError_(contentType) {
  883.     const operation = this.queues_[contentType][0];
  884.     goog.asserts.assert(operation, 'Spurious error event!');
  885.     goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
  886.         'SourceBuffer should not be updating on error!');
  887.     const code = this.video_.error ? this.video_.error.code : 0;
  888.     operation.p.reject(new shaka.util.Error(
  889.         shaka.util.Error.Severity.CRITICAL,
  890.         shaka.util.Error.Category.MEDIA,
  891.         shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_FAILED,
  892.         code));
  893.     // Do not pop from queue.  An 'updateend' event will fire next, and to
  894.     // avoid synchronizing these two event handlers, we will allow that one to
  895.     // pop from the queue as normal.  Note that because the operation has
  896.     // already been rejected, the call to resolve() in the 'updateend' handler
  897.     // will have no effect.
  898.   }
  900.   /**
  901.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  902.    * @private
  903.    */
  904.   onUpdateEnd_(contentType) {
  905.     const operation = this.queues_[contentType][0];
  906.     goog.asserts.assert(operation, 'Spurious updateend event!');
  907.     if (!operation) {
  908.       return;
  909.     }
  910.     goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
  911.         'SourceBuffer should not be updating on updateend!');
  912.     operation.p.resolve();
  913.     this.popFromQueue_(contentType);
  914.   }
  916.   /**
  917.    * Enqueue an operation and start it if appropriate.
  918.    *
  919.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  920.    * @param {function()} start
  921.    * @return {!Promise}
  922.    * @private
  923.    */
  924.   enqueueOperation_(contentType, start) {
  925.     this.destroyer_.ensureNotDestroyed();
  927.     const operation = {
  928.       start: start,
  929.       p: new shaka.util.PublicPromise(),
  930.     };
  931.     this.queues_[contentType].push(operation);
  933.     if (this.queues_[contentType].length == 1) {
  934.       this.startOperation_(contentType);
  935.     }
  936.     return operation.p;
  937.   }
  939.   /**
  940.    * Enqueue an operation which must block all other operations on all
  941.    * SourceBuffers.
  942.    *
  943.    * @param {function()} run
  944.    * @return {!Promise}
  945.    * @private
  946.    */
  947.   async enqueueBlockingOperation_(run) {
  948.     this.destroyer_.ensureNotDestroyed();
  950.     /** @type {!Array.<!shaka.util.PublicPromise>} */
  951.     const allWaiters = [];
  953.     // Enqueue a 'wait' operation onto each queue.
  954.     // This operation signals its readiness when it starts.
  955.     // When all wait operations are ready, the real operation takes place.
  956.     for (const contentType in this.sourceBuffers_) {
  957.       const ready = new shaka.util.PublicPromise();
  958.       const operation = {
  959.         start: () => ready.resolve(),
  960.         p: ready,
  961.       };
  963.       this.queues_[contentType].push(operation);
  964.       allWaiters.push(ready);
  966.       if (this.queues_[contentType].length == 1) {
  967.         operation.start();
  968.       }
  969.     }
  971.     // Return a Promise to the real operation, which waits to begin until
  972.     // there are no other in-progress operations on any SourceBuffers.
  973.     try {
  974.       await Promise.all(allWaiters);
  975.     } catch (error) {
  976.       // One of the waiters failed, which means we've been destroyed.
  977.       goog.asserts.assert(
  978.           this.destroyer_.destroyed(), 'Should be destroyed by now');
  979.       // We haven't popped from the queue.  Canceled waiters have been removed
  980.       // by destroy.  What's left now should just be resolved waiters.  In
  981.       // uncompiled mode, we will maintain good hygiene and make sure the
  982.       // assert at the end of destroy passes.  In compiled mode, the queues
  983.       // are wiped in destroy.
  984.       if (goog.DEBUG) {
  985.         for (const contentType in this.sourceBuffers_) {
  986.           if (this.queues_[contentType].length) {
  987.             goog.asserts.assert(
  988.                 this.queues_[contentType].length == 1,
  989.                 'Should be at most one item in queue!');
  990.             goog.asserts.assert(
  991.                 allWaiters.includes(this.queues_[contentType][0].p),
  992.                 'The item in queue should be one of our waiters!');
  993.             this.queues_[contentType].shift();
  994.           }
  995.         }
  996.       }
  997.       throw error;
  998.     }
  1000.     if (goog.DEBUG) {
  1001.       // If we did it correctly, nothing is updating.
  1002.       for (const contentType in this.sourceBuffers_) {
  1003.         goog.asserts.assert(
  1004.             this.sourceBuffers_[contentType].updating == false,
  1005.             'SourceBuffers should not be updating after a blocking op!');
  1006.       }
  1007.     }
  1009.     // Run the real operation, which is synchronous.
  1010.     try {
  1011.       run();
  1012.     } catch (exception) {
  1013.       throw new shaka.util.Error(
  1014.           shaka.util.Error.Severity.CRITICAL,
  1015.           shaka.util.Error.Category.MEDIA,
  1016.           shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  1017.           exception);
  1018.     } finally {
  1019.       // Unblock the queues.
  1020.       for (const contentType in this.sourceBuffers_) {
  1021.         this.popFromQueue_(contentType);
  1022.       }
  1023.     }
  1024.   }
  1026.   /**
  1027.    * Pop from the front of the queue and start a new operation.
  1028.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1029.    * @private
  1030.    */
  1031.   popFromQueue_(contentType) {
  1032.     // Remove the in-progress operation, which is now complete.
  1033.     this.queues_[contentType].shift();
  1034.     this.startOperation_(contentType);
  1035.   }
  1037.   /**
  1038.    * Starts the next operation in the queue.
  1039.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1040.    * @private
  1041.    */
  1042.   startOperation_(contentType) {
  1043.     // Retrieve the next operation, if any, from the queue and start it.
  1044.     const next = this.queues_[contentType][0];
  1045.     if (next) {
  1046.       try {
  1047.         next.start();
  1048.       } catch (exception) {
  1049.         if (exception.name == 'QuotaExceededError') {
  1050.           next.p.reject(new shaka.util.Error(
  1051.               shaka.util.Error.Severity.CRITICAL,
  1052.               shaka.util.Error.Category.MEDIA,
  1053.               shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR,
  1054.               contentType));
  1055.         } else {
  1056.           next.p.reject(new shaka.util.Error(
  1057.               shaka.util.Error.Severity.CRITICAL,
  1058.               shaka.util.Error.Category.MEDIA,
  1059.               shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
  1060.               exception));
  1061.         }
  1062.         this.popFromQueue_(contentType);
  1063.       }
  1064.     }
  1065.   }
  1067.   /**
  1068.    * @return {!shaka.extern.TextDisplayer}
  1069.    */
  1070.   getTextDisplayer() {
  1071.     goog.asserts.assert(
  1072.         this.textDisplayer_,
  1073.         'TextDisplayer should only be null when this is destroyed');
  1075.     return this.textDisplayer_;
  1076.   }
  1078.   /**
  1079.    * @param {!shaka.extern.TextDisplayer} textDisplayer
  1080.    */
  1081.   setTextDisplayer(textDisplayer) {
  1082.     const oldTextDisplayer = this.textDisplayer_;
  1083.     this.textDisplayer_ = textDisplayer;
  1084.     if (oldTextDisplayer) {
  1085.       textDisplayer.setTextVisibility(oldTextDisplayer.isTextVisible());
  1086.       oldTextDisplayer.destroy();
  1087.     }
  1088.     if (this.textEngine_) {
  1089.       this.textEngine_.setDisplayer(textDisplayer);
  1090.     }
  1091.   }
  1093.   /**
  1094.    * Apply platform-specific transformations to this segment to work around
  1095.    * issues in the platform.
  1096.    *
  1097.    * @param {!BufferSource} segment
  1098.    * @param {?number} startTime
  1099.    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
  1100.    * @return {!BufferSource}
  1101.    * @private
  1102.    */
  1103.   workAroundBrokenPlatforms_(segment, startTime, contentType) {
  1104.     const isInitSegment = startTime == null;
  1105.     const encryptionExpected = this.expectedEncryption_[contentType];
  1107.     // If:
  1108.     //   1. this is an init segment,
  1109.     //   2. and encryption is expected,
  1110.     //   3. and the platform requires encryption in all init segments,
  1111.     //   4. and the content is MP4 (mimeType == "video/mp4" or "audio/mp4"),
  1112.     // then insert fake encryption metadata for init segments that lack it.
  1113.     // The MP4 requirement is because we can currently only do this
  1114.     // transformation on MP4 containers.
  1115.     // See: https://github.com/shaka-project/shaka-player/issues/2759
  1116.     if (isInitSegment &&
  1117.         encryptionExpected &&
  1118.         shaka.util.Platform.requiresEncryptionInfoInAllInitSegments() &&
  1119.         shaka.util.MimeUtils.getContainerType(
  1120.             this.sourceBufferTypes_[contentType]) == 'mp4') {
  1121.       shaka.log.debug('Forcing fake encryption information in init segment.');
  1122.       segment = shaka.media.ContentWorkarounds.fakeEncryption(segment);
  1123.     }
  1125.     return segment;
  1126.   }
  1127. };
  1130. /**
  1131.  * Internal reference to window.URL.createObjectURL function to avoid
  1132.  * compatibility issues with other libraries and frameworks such as React
  1133.  * Native. For use in unit tests only, not meant for external use.
  1134.  *
  1135.  * @type {function(?):string}
  1136.  */
  1137. shaka.media.MediaSourceEngine.createObjectURL = window.URL.createObjectURL;
  1140. /**
  1141.  * @typedef {{
  1142.  *   start: function(),
  1143.  *   p: !shaka.util.PublicPromise
  1144.  * }}
  1145.  *
  1146.  * @summary An operation in queue.
  1147.  * @property {function()} start
  1148.  *   The function which starts the operation.
  1149.  * @property {!shaka.util.PublicPromise} p
  1150.  *   The PublicPromise which is associated with this operation.
  1151.  */
  1152. shaka.media.MediaSourceEngine.Operation;