Source: lib/media/streaming_engine.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. /**
  8.  * @fileoverview
  9.  * @suppress {missingRequire} TODO(b/152540451): this shouldn't be needed
  10.  */
  12. goog.provide('shaka.media.StreamingEngine');
  14. goog.require('goog.asserts');
  15. goog.require('shaka.log');
  16. goog.require('shaka.media.InitSegmentReference');
  17. goog.require('shaka.media.MediaSourceEngine');
  18. goog.require('shaka.media.SegmentIterator');
  19. goog.require('shaka.media.SegmentReference');
  20. goog.require('shaka.net.Backoff');
  21. goog.require('shaka.net.NetworkingEngine');
  22. goog.require('shaka.util.DelayedTick');
  23. goog.require('shaka.util.Destroyer');
  24. goog.require('shaka.util.Error');
  25. goog.require('shaka.util.FakeEvent');
  26. goog.require('shaka.util.IDestroyable');
  27. goog.require('shaka.util.ManifestParserUtils');
  28. goog.require('shaka.util.MimeUtils');
  29. goog.require('shaka.util.Mp4Parser');
  30. goog.require('shaka.util.Networking');
  33. /**
  34.  * @summary Creates a Streaming Engine.
  35.  * The StreamingEngine is responsible for setting up the Manifest's Streams
  36.  * (i.e., for calling each Stream's createSegmentIndex() function), for
  37.  * downloading segments, for co-ordinating audio, video, and text buffering.
  38.  * The StreamingEngine provides an interface to switch between Streams, but it
  39.  * does not choose which Streams to switch to.
  40.  *
  41.  * The StreamingEngine does not need to be notified about changes to the
  42.  * Manifest's SegmentIndexes; however, it does need to be notified when new
  43.  * Variants are added to the Manifest.
  44.  *
  45.  * To start the StreamingEngine the owner must first call configure(), followed
  46.  * by one call to switchVariant(), one optional call to switchTextStream(), and
  47.  * finally a call to start().  After start() resolves, switch*() can be used
  48.  * freely.
  49.  *
  50.  * The owner must call seeked() each time the playhead moves to a new location
  51.  * within the presentation timeline; however, the owner may forego calling
  52.  * seeked() when the playhead moves outside the presentation timeline.
  53.  *
  54.  * @implements {shaka.util.IDestroyable}
  55.  */
  56. shaka.media.StreamingEngine = class {
  57.   /**
  58.    * @param {shaka.extern.Manifest} manifest
  59.    * @param {shaka.media.StreamingEngine.PlayerInterface} playerInterface
  60.    */
  61.   constructor(manifest, playerInterface) {
  62.     /** @private {?shaka.media.StreamingEngine.PlayerInterface} */
  63.     this.playerInterface_ = playerInterface;
  65.     /** @private {?shaka.extern.Manifest} */
  66.     this.manifest_ = manifest;
  68.     /** @private {?shaka.extern.StreamingConfiguration} */
  69.     this.config_ = null;
  71.     /** @private {number} */
  72.     this.bufferingGoalScale_ = 1;
  74.     /** @private {?shaka.extern.Variant} */
  75.     this.currentVariant_ = null;
  77.     /** @private {?shaka.extern.Stream} */
  78.     this.currentTextStream_ = null;
  80.     /**
  81.      * Maps a content type, e.g., 'audio', 'video', or 'text', to a MediaState.
  82.      *
  83.      * @private {!Map.<shaka.util.ManifestParserUtils.ContentType,
  84.      *                 !shaka.media.StreamingEngine.MediaState_>}
  85.      */
  86.     this.mediaStates_ = new Map();
  88.     /**
  89.      * Set to true once the initial media states have been created.
  90.      *
  91.      * @private {boolean}
  92.      */
  93.     this.startupComplete_ = false;
  95.     /**
  96.      * Used for delay and backoff of failure callbacks, so that apps do not
  97.      * retry instantly.
  98.      *
  99.      * @private {shaka.net.Backoff}
  100.      */
  101.     this.failureCallbackBackoff_ = null;
  103.     /**
  104.      * Set to true on fatal error.  Interrupts fetchAndAppend_().
  105.      *
  106.      * @private {boolean}
  107.      */
  108.     this.fatalError_ = false;
  110.     /** @private {!shaka.util.Destroyer} */
  111.     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
  112.   }
  114.   /** @override */
  115.   destroy() {
  116.     return this.destroyer_.destroy();
  117.   }
  119.   /**
  120.    * @return {!Promise}
  121.    * @private
  122.    */
  123.   async doDestroy_() {
  124.     const aborts = [];
  126.     for (const state of this.mediaStates_.values()) {
  127.       this.cancelUpdate_(state);
  128.       aborts.push(this.abortOperations_(state));
  129.     }
  131.     await Promise.all(aborts);
  133.     this.mediaStates_.clear();
  135.     this.playerInterface_ = null;
  136.     this.manifest_ = null;
  137.     this.config_ = null;
  138.   }
  140.   /**
  141.    * Called by the Player to provide an updated configuration any time it
  142.    * changes. Must be called at least once before start().
  143.    *
  144.    * @param {shaka.extern.StreamingConfiguration} config
  145.    */
  146.   configure(config) {
  147.     this.config_ = config;
  149.     // Create separate parameters for backoff during streaming failure.
  151.     /** @type {shaka.extern.RetryParameters} */
  152.     const failureRetryParams = {
  153.       // The term "attempts" includes the initial attempt, plus all retries.
  154.       // In order to see a delay, there would have to be at least 2 attempts.
  155.       maxAttempts: Math.max(config.retryParameters.maxAttempts, 2),
  156.       baseDelay: config.retryParameters.baseDelay,
  157.       backoffFactor: config.retryParameters.backoffFactor,
  158.       fuzzFactor: config.retryParameters.fuzzFactor,
  159.       timeout: 0,  // irrelevant
  160.       stallTimeout: 0, // irrelevant
  161.       connectionTimeout: 0, // irrelevant
  162.     };
  164.     // We don't want to ever run out of attempts.  The application should be
  165.     // allowed to retry streaming infinitely if it wishes.
  166.     const autoReset = true;
  167.     this.failureCallbackBackoff_ =
  168.         new shaka.net.Backoff(failureRetryParams, autoReset);
  169.   }
  172.   /**
  173.    * Initialize and start streaming.
  174.    *
  175.    * By calling this method, StreamingEngine will start streaming the variant
  176.    * chosen by a prior call to switchVariant(), and optionally, the text stream
  177.    * chosen by a prior call to switchTextStream().  Once the Promise resolves,
  178.    * switch*() may be called freely.
  179.    *
  180.    * @return {!Promise}
  181.    */
  182.   async start() {
  183.     goog.asserts.assert(this.config_,
  184.         'StreamingEngine configure() must be called before init()!');
  186.     // Setup the initial set of Streams and then begin each update cycle.
  187.     await this.initStreams_();
  188.     this.destroyer_.ensureNotDestroyed();
  190.     shaka.log.debug('init: completed initial Stream setup');
  191.     this.startupComplete_ = true;
  192.   }
  194.   /**
  195.    * Get the current variant we are streaming.  Returns null if nothing is
  196.    * streaming.
  197.    * @return {?shaka.extern.Variant}
  198.    */
  199.   getCurrentVariant() {
  200.     return this.currentVariant_;
  201.   }
  203.   /**
  204.    * Get the text stream we are streaming.  Returns null if there is no text
  205.    * streaming.
  206.    * @return {?shaka.extern.Stream}
  207.    */
  208.   getCurrentTextStream() {
  209.     return this.currentTextStream_;
  210.   }
  212.   /**
  213.    * Start streaming text, creating a new media state.
  214.    *
  215.    * @param {shaka.extern.Stream} stream
  216.    * @return {!Promise}
  217.    * @private
  218.    */
  219.   async loadNewTextStream_(stream) {
  220.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  221.     goog.asserts.assert(!this.mediaStates_.has(ContentType.TEXT),
  222.         'Should not call loadNewTextStream_ while streaming text!');
  224.     try {
  225.       // Clear MediaSource's buffered text, so that the new text stream will
  226.       // properly replace the old buffered text.
  227.       // TODO: Should this happen in unloadTextStream() instead?
  228.       await this.playerInterface_.mediaSourceEngine.clear(ContentType.TEXT);
  229.     } catch (error) {
  230.       if (this.playerInterface_) {
  231.         this.playerInterface_.onError(error);
  232.       }
  233.     }
  235.     const mimeType = shaka.util.MimeUtils.getFullType(
  236.         stream.mimeType, stream.codecs);
  237.     this.playerInterface_.mediaSourceEngine.reinitText(
  238.         mimeType, this.manifest_.sequenceMode);
  240.     const textDisplayer =
  241.         this.playerInterface_.mediaSourceEngine.getTextDisplayer();
  242.     const streamText =
  243.         textDisplayer.isTextVisible() || this.config_.alwaysStreamText;
  245.     if (streamText) {
  246.       const state = this.createMediaState_(stream);
  247.       this.mediaStates_.set(ContentType.TEXT, state);
  248.       this.scheduleUpdate_(state, 0);
  249.     }
  250.   }
  253.   /**
  254.    * Stop fetching text stream when the user chooses to hide the captions.
  255.    */
  256.   unloadTextStream() {
  257.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  259.     const state = this.mediaStates_.get(ContentType.TEXT);
  260.     if (state) {
  261.       this.cancelUpdate_(state);
  262.       this.abortOperations_(state).catch(() => {});
  263.       this.mediaStates_.delete(ContentType.TEXT);
  264.     }
  265.     this.currentTextStream_ = null;
  266.   }
  268.   /**
  269.    * Set trick play on or off.
  270.    * If trick play is on, related trick play streams will be used when possible.
  271.    * @param {boolean} on
  272.    */
  273.   setTrickPlay(on) {
  274.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  276.     const mediaState = this.mediaStates_.get(ContentType.VIDEO);
  277.     if (!mediaState) {
  278.       return;
  279.     }
  281.     const stream = mediaState.stream;
  282.     if (!stream) {
  283.       return;
  284.     }
  286.     shaka.log.debug('setTrickPlay', on);
  287.     if (on) {
  288.       const trickModeVideo = stream.trickModeVideo;
  289.       if (!trickModeVideo) {
  290.         return;  // Can't engage trick play.
  291.       }
  293.       const normalVideo = mediaState.restoreStreamAfterTrickPlay;
  294.       if (normalVideo) {
  295.         return;  // Already in trick play.
  296.       }
  298.       shaka.log.debug('Engaging trick mode stream', trickModeVideo);
  299.       this.switchInternal_(trickModeVideo, /* clearBuffer= */ false,
  300.           /* safeMargin= */ 0, /* force= */ false);
  302.       mediaState.restoreStreamAfterTrickPlay = stream;
  303.     } else {
  304.       const normalVideo = mediaState.restoreStreamAfterTrickPlay;
  305.       if (!normalVideo) {
  306.         return;
  307.       }
  309.       shaka.log.debug('Restoring non-trick-mode stream', normalVideo);
  310.       mediaState.restoreStreamAfterTrickPlay = null;
  311.       this.switchInternal_(normalVideo, /* clearBuffer= */ true,
  312.           /* safeMargin= */ 0, /* force= */ false);
  313.     }
  314.   }
  317.   /**
  318.    * @param {shaka.extern.Variant} variant
  319.    * @param {boolean=} clearBuffer
  320.    * @param {number=} safeMargin
  321.    * @param {boolean=} force
  322.    *   If true, reload the variant even if it did not change.
  323.    * @param {boolean=} adaptation
  324.    *   If true, update the media state to indicate MediaSourceEngine should
  325.    *   reset the timestamp offset to ensure the new track segments are correctly
  326.    *   placed on the timeline.
  327.    */
  328.   switchVariant(
  329.       variant, clearBuffer = false, safeMargin = 0, force = false,
  330.       adaptation = false) {
  331.     this.currentVariant_ = variant;
  333.     if (!this.startupComplete_) {
  334.       // The selected variant will be used in start().
  335.       return;
  336.     }
  338.     if (variant.video) {
  339.       this.switchInternal_(
  340.           variant.video, /* clearBuffer= */ clearBuffer,
  341.           /* safeMargin= */ safeMargin, /* force= */ force,
  342.           /* adaptation= */ adaptation);
  343.     }
  344.     if (variant.audio) {
  345.       this.switchInternal_(
  346.           variant.audio, /* clearBuffer= */ clearBuffer,
  347.           /* safeMargin= */ safeMargin, /* force= */ force,
  348.           /* adaptation= */ adaptation);
  349.     }
  350.   }
  353.   /**
  354.    * @param {shaka.extern.Stream} textStream
  355.    */
  356.   switchTextStream(textStream) {
  357.     this.currentTextStream_ = textStream;
  359.     if (!this.startupComplete_) {
  360.       // The selected text stream will be used in start().
  361.       return;
  362.     }
  364.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  365.     goog.asserts.assert(textStream && textStream.type == ContentType.TEXT,
  366.         'Wrong stream type passed to switchTextStream!');
  368.     this.switchInternal_(
  369.         textStream, /* clearBuffer= */ true,
  370.         /* safeMargin= */ 0, /* force= */ false);
  371.   }
  374.   /** Reload the current text stream. */
  375.   reloadTextStream() {
  376.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  377.     const mediaState = this.mediaStates_.get(ContentType.TEXT);
  378.     if (mediaState) { // Don't reload if there's no text to begin with.
  379.       this.switchInternal_(
  380.           mediaState.stream, /* clearBuffer= */ true,
  381.           /* safeMargin= */ 0, /* force= */ true);
  382.     }
  383.   }
  386.   /**
  387.    * Switches to the given Stream. |stream| may be from any Variant.
  388.    *
  389.    * @param {shaka.extern.Stream} stream
  390.    * @param {boolean} clearBuffer
  391.    * @param {number} safeMargin
  392.    * @param {boolean} force
  393.    *   If true, reload the text stream even if it did not change.
  394.    * @param {boolean=} adaptation
  395.    *   If true, update the media state to indicate MediaSourceEngine should
  396.    *   reset the timestamp offset to ensure the new track segments are correctly
  397.    *   placed on the timeline.
  398.    * @private
  399.    */
  400.   switchInternal_(stream, clearBuffer, safeMargin, force, adaptation) {
  401.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  402.     const type = /** @type {!ContentType} */(stream.type);
  403.     const mediaState = this.mediaStates_.get(type);
  405.     if (!mediaState && stream.type == ContentType.TEXT) {
  406.       this.loadNewTextStream_(stream);
  407.       return;
  408.     }
  410.     goog.asserts.assert(mediaState, 'switch: expected mediaState to exist');
  411.     if (!mediaState) {
  412.       return;
  413.     }
  415.     if (mediaState.restoreStreamAfterTrickPlay) {
  416.       shaka.log.debug('switch during trick play mode', stream);
  418.       // Already in trick play mode, so stick with trick mode tracks if
  419.       // possible.
  420.       if (stream.trickModeVideo) {
  421.         // Use the trick mode stream, but revert to the new selection later.
  422.         mediaState.restoreStreamAfterTrickPlay = stream;
  423.         stream = stream.trickModeVideo;
  424.         shaka.log.debug('switch found trick play stream', stream);
  425.       } else {
  426.         // There is no special trick mode video for this stream!
  427.         mediaState.restoreStreamAfterTrickPlay = null;
  428.         shaka.log.debug('switch found no special trick play stream');
  429.       }
  430.     }
  432.     if (mediaState.stream == stream && !force) {
  433.       const streamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
  434.       shaka.log.debug('switch: Stream ' + streamTag + ' already active');
  435.       return;
  436.     }
  438.     if (stream.type == ContentType.TEXT) {
  439.       // Mime types are allowed to change for text streams.
  440.       // Reinitialize the text parser, but only if we are going to fetch the
  441.       // init segment again.
  442.       const fullMimeType = shaka.util.MimeUtils.getFullType(
  443.           stream.mimeType, stream.codecs);
  444.       this.playerInterface_.mediaSourceEngine.reinitText(
  445.           fullMimeType, this.manifest_.sequenceMode);
  446.     }
  448.     // Releases the segmentIndex of the old stream.
  449.     if (mediaState.stream.closeSegmentIndex) {
  450.       mediaState.stream.closeSegmentIndex();
  451.     }
  453.     mediaState.stream = stream;
  454.     mediaState.segmentIterator = null;
  455.     mediaState.adaptation = !!adaptation;
  457.     const streamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
  458.     shaka.log.debug('switch: switching to Stream ' + streamTag);
  460.     if (clearBuffer) {
  461.       if (mediaState.clearingBuffer) {
  462.         // We are already going to clear the buffer, but make sure it is also
  463.         // flushed.
  464.         mediaState.waitingToFlushBuffer = true;
  465.       } else if (mediaState.performingUpdate) {
  466.         // We are performing an update, so we have to wait until it's finished.
  467.         // onUpdate_() will call clearBuffer_() when the update has finished.
  468.         // We need to save the safe margin because its value will be needed when
  469.         // clearing the buffer after the update.
  470.         mediaState.waitingToClearBuffer = true;
  471.         mediaState.clearBufferSafeMargin = safeMargin;
  472.         mediaState.waitingToFlushBuffer = true;
  473.       } else {
  474.         // Cancel the update timer, if any.
  475.         this.cancelUpdate_(mediaState);
  476.         // Clear right away.
  477.         this.clearBuffer_(mediaState, /* flush= */ true, safeMargin)
  478.             .catch((error) => {
  479.               if (this.playerInterface_) {
  480.                 goog.asserts.assert(error instanceof shaka.util.Error,
  481.                     'Wrong error type!');
  482.                 this.playerInterface_.onError(error);
  483.               }
  484.             });
  485.       }
  486.     }
  488.     this.makeAbortDecision_(mediaState).catch((error) => {
  489.       if (this.playerInterface_) {
  490.         goog.asserts.assert(error instanceof shaka.util.Error,
  491.             'Wrong error type!');
  492.         this.playerInterface_.onError(error);
  493.       }
  494.     });
  495.   }
  498.   /**
  499.    * Decide if it makes sense to abort the current operation, and abort it if
  500.    * so.
  501.    *
  502.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  503.    * @private
  504.    */
  505.   async makeAbortDecision_(mediaState) {
  506.     // If the operation is completed, it will be set to null, and there's no
  507.     // need to abort the request.
  508.     if (!mediaState.operation) {
  509.       return;
  510.     }
  512.     const originalStream = mediaState.stream;
  513.     const originalOperation = mediaState.operation;
  515.     if (!originalStream.segmentIndex) {
  516.       // Create the new segment index so the time taken is accounted for when
  517.       // deciding whether to abort.
  518.       await originalStream.createSegmentIndex();
  519.     }
  521.     if (mediaState.operation != originalOperation) {
  522.       // The original operation completed while we were getting a segment index,
  523.       // so there's nothing to do now.
  524.       return;
  525.     }
  527.     if (mediaState.stream != originalStream) {
  528.       // The stream changed again while we were getting a segment index.  We
  529.       // can't carry out this check, since another one might be in progress by
  530.       // now.
  531.       return;
  532.     }
  534.     goog.asserts.assert(mediaState.stream.segmentIndex,
  535.         'Segment index should exist by now!');
  537.     if (this.shouldAbortCurrentRequest_(mediaState)) {
  538.       shaka.log.info('Aborting current segment request.');
  539.       mediaState.operation.abort();
  540.     }
  541.   }
  543.   /**
  544.    * Returns whether we should abort the current request.
  545.    *
  546.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  547.    * @return {boolean}
  548.    * @private
  549.    */
  550.   shouldAbortCurrentRequest_(mediaState) {
  551.     goog.asserts.assert(mediaState.operation,
  552.         'Abort logic requires an ongoing operation!');
  553.     goog.asserts.assert(mediaState.stream && mediaState.stream.segmentIndex,
  554.         'Abort logic requires a segment index');
  556.     const presentationTime = this.playerInterface_.getPresentationTime();
  557.     const bufferEnd =
  558.         this.playerInterface_.mediaSourceEngine.bufferEnd(mediaState.type);
  560.     // The next segment to append from the current stream.  This doesn't
  561.     // account for a pending network request and will likely be different from
  562.     // that since we just switched.
  563.     const timeNeeded = this.getTimeNeeded_(mediaState, presentationTime);
  564.     const index = mediaState.stream.segmentIndex.find(timeNeeded);
  565.     const newSegment =
  566.         index == null ? null : mediaState.stream.segmentIndex.get(index);
  568.     let newSegmentSize = newSegment ? newSegment.getSize() : null;
  569.     if (newSegment && !newSegmentSize) {
  570.       // compute approximate segment size using stream bandwidth
  571.       const duration = newSegment.getEndTime() - newSegment.getStartTime();
  572.       const bandwidth = mediaState.stream.bandwidth || 0;
  573.       // bandwidth is in bits per second, and the size is in bytes
  574.       newSegmentSize = duration * bandwidth / 8;
  575.     }
  577.     if (!newSegmentSize) {
  578.       return false;
  579.     }
  581.     // When switching, we'll need to download the init segment.
  582.     const init = newSegment.initSegmentReference;
  583.     if (init) {
  584.       newSegmentSize += init.getSize() || 0;
  585.     }
  587.     const bandwidthEstimate = this.playerInterface_.getBandwidthEstimate();
  589.     // The estimate is in bits per second, and the size is in bytes.  The time
  590.     // remaining is in seconds after this calculation.
  591.     const timeToFetchNewSegment = (newSegmentSize * 8) / bandwidthEstimate;
  593.     // If the new segment can be finished in time without risking a buffer
  594.     // underflow, we should abort the old one and switch.
  595.     const bufferedAhead = (bufferEnd || 0) - presentationTime;
  596.     const safetyBuffer = Math.max(
  597.         this.manifest_.minBufferTime || 0,
  598.         this.config_.rebufferingGoal);
  599.     const safeBufferedAhead = bufferedAhead - safetyBuffer;
  600.     if (timeToFetchNewSegment < safeBufferedAhead) {
  601.       return true;
  602.     }
  604.     // If the thing we want to switch to will be done more quickly than what
  605.     // we've got in progress, we should abort the old one and switch.
  606.     const bytesRemaining = mediaState.operation.getBytesRemaining();
  607.     if (bytesRemaining > newSegmentSize) {
  608.       return true;
  609.     }
  611.     // Otherwise, complete the operation in progress.
  612.     return false;
  613.   }
  616.   /**
  617.    * Notifies the StreamingEngine that the playhead has moved to a valid time
  618.    * within the presentation timeline.
  619.    */
  620.   seeked() {
  621.     const presentationTime = this.playerInterface_.getPresentationTime();
  622.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  623.     const newTimeIsBuffered = (type) => {
  624.       return this.playerInterface_.mediaSourceEngine.isBuffered(
  625.           type, presentationTime);
  626.     };
  628.     let streamCleared = false;
  629.     for (const type of this.mediaStates_.keys()) {
  630.       const mediaState = this.mediaStates_.get(type);
  631.       const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  633.       // Always clear the iterator since we need to start streaming from the
  634.       // new time.  This also happens in clearBuffer_, but if we don't clear,
  635.       // we still want to reset the iterator.
  636.       mediaState.segmentIterator = null;
  638.       if (!newTimeIsBuffered(type)) {
  639.         const bufferEnd =
  640.             this.playerInterface_.mediaSourceEngine.bufferEnd(type);
  641.         const somethingBuffered = bufferEnd != null;
  643.         // Don't clear the buffer unless something is buffered.  This extra
  644.         // check prevents extra, useless calls to clear the buffer.
  645.         if (somethingBuffered || mediaState.performingUpdate) {
  646.           this.forceClearBuffer_(mediaState);
  647.           streamCleared = true;
  648.         }
  650.         // If there is an operation in progress, stop it now.
  651.         if (mediaState.operation) {
  652.           mediaState.operation.abort();
  653.           shaka.log.debug(logPrefix, 'Aborting operation due to seek');
  654.           mediaState.operation = null;
  655.         }
  657.         // The pts has shifted from the seek, invalidating captions currently
  658.         // in the text buffer. Thus, clear and reset the caption parser.
  659.         if (type === ContentType.TEXT) {
  660.           this.playerInterface_.mediaSourceEngine.resetCaptionParser();
  661.         }
  663.         // Mark the media state as having seeked, so that the new buffers know
  664.         // that they will need to be at a new position (for sequence mode).
  665.         mediaState.seeked = true;
  666.       }
  667.     }
  669.     if (!streamCleared) {
  670.       shaka.log.debug(
  671.           '(all): seeked: buffered seek: presentationTime=' + presentationTime);
  672.     }
  673.   }
  676.   /**
  677.    * Clear the buffer for a given stream.  Unlike clearBuffer_, this will handle
  678.    * cases where a MediaState is performing an update.  After this runs, every
  679.    * MediaState will have a pending update.
  680.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  681.    * @private
  682.    */
  683.   forceClearBuffer_(mediaState) {
  684.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  686.     if (mediaState.clearingBuffer) {
  687.       // We're already clearing the buffer, so we don't need to clear the
  688.       // buffer again.
  689.       shaka.log.debug(logPrefix, 'clear: already clearing the buffer');
  690.       return;
  691.     }
  693.     if (mediaState.waitingToClearBuffer) {
  694.       // May not be performing an update, but an update will still happen.
  695.       // See: https://github.com/shaka-project/shaka-player/issues/334
  696.       shaka.log.debug(logPrefix, 'clear: already waiting');
  697.       return;
  698.     }
  700.     if (mediaState.performingUpdate) {
  701.       // We are performing an update, so we have to wait until it's finished.
  702.       // onUpdate_() will call clearBuffer_() when the update has finished.
  703.       shaka.log.debug(logPrefix, 'clear: currently updating');
  704.       mediaState.waitingToClearBuffer = true;
  705.       // We can set the offset to zero to remember that this was a call to
  706.       // clearAllBuffers.
  707.       mediaState.clearBufferSafeMargin = 0;
  708.       return;
  709.     }
  711.     const type = mediaState.type;
  712.     if (this.playerInterface_.mediaSourceEngine.bufferStart(type) == null) {
  713.       // Nothing buffered.
  714.       shaka.log.debug(logPrefix, 'clear: nothing buffered');
  715.       if (mediaState.updateTimer == null) {
  716.         // Note: an update cycle stops when we buffer to the end of the
  717.         // presentation, or when we raise an error.
  718.         this.scheduleUpdate_(mediaState, 0);
  719.       }
  720.       return;
  721.     }
  723.     // An update may be scheduled, but we can just cancel it and clear the
  724.     // buffer right away. Note: clearBuffer_() will schedule the next update.
  725.     shaka.log.debug(logPrefix, 'clear: handling right now');
  726.     this.cancelUpdate_(mediaState);
  727.     this.clearBuffer_(mediaState, /* flush= */ false, 0).catch((error) => {
  728.       if (this.playerInterface_) {
  729.         goog.asserts.assert(error instanceof shaka.util.Error,
  730.             'Wrong error type!');
  731.         this.playerInterface_.onError(error);
  732.       }
  733.     });
  734.   }
  737.   /**
  738.    * Initializes the initial streams and media states.  This will schedule
  739.    * updates for the given types.
  740.    *
  741.    * @return {!Promise}
  742.    * @private
  743.    */
  744.   async initStreams_() {
  745.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  747.     goog.asserts.assert(this.config_,
  748.         'StreamingEngine configure() must be called before init()!');
  750.     if (!this.currentVariant_) {
  751.       shaka.log.error('init: no Streams chosen');
  752.       throw new shaka.util.Error(
  753.           shaka.util.Error.Severity.CRITICAL,
  754.           shaka.util.Error.Category.STREAMING,
  755.           shaka.util.Error.Code.STREAMING_ENGINE_STARTUP_INVALID_STATE);
  756.     }
  758.     /**
  759.      * @type {!Map.<shaka.util.ManifestParserUtils.ContentType,
  760.      *              shaka.extern.Stream>}
  761.      */
  762.     const streamsByType = new Map();
  763.     /** @type {!Set.<shaka.extern.Stream>} */
  764.     const streams = new Set();
  766.     if (this.currentVariant_.audio) {
  767.       streamsByType.set(ContentType.AUDIO, this.currentVariant_.audio);
  768.       streams.add(this.currentVariant_.audio);
  769.     }
  771.     if (this.currentVariant_.video) {
  772.       streamsByType.set(ContentType.VIDEO, this.currentVariant_.video);
  773.       streams.add(this.currentVariant_.video);
  774.     }
  776.     if (this.currentTextStream_) {
  777.       streamsByType.set(ContentType.TEXT, this.currentTextStream_);
  778.       streams.add(this.currentTextStream_);
  779.     }
  781.     // Init MediaSourceEngine.
  782.     const mediaSourceEngine = this.playerInterface_.mediaSourceEngine;
  783.     const forceTransmuxTS = this.config_.forceTransmuxTS;
  785.     await mediaSourceEngine.init(streamsByType, forceTransmuxTS,
  786.         this.manifest_.sequenceMode);
  787.     this.destroyer_.ensureNotDestroyed();
  789.     this.updateDuration();
  791.     for (const type of streamsByType.keys()) {
  792.       const stream = streamsByType.get(type);
  793.       if (!this.mediaStates_.has(type)) {
  794.         const state = this.createMediaState_(stream);
  795.         this.mediaStates_.set(type, state);
  796.         this.scheduleUpdate_(state, 0);
  797.       }
  798.     }
  799.   }
  802.   /**
  803.    * Creates a media state.
  804.    *
  805.    * @param {shaka.extern.Stream} stream
  806.    * @return {shaka.media.StreamingEngine.MediaState_}
  807.    * @private
  808.    */
  809.   createMediaState_(stream) {
  810.     return /** @type {shaka.media.StreamingEngine.MediaState_} */ ({
  811.       stream,
  812.       type: stream.type,
  813.       segmentIterator: null,
  814.       lastSegmentReference: null,
  815.       lastInitSegmentReference: null,
  816.       lastTimestampOffset: null,
  817.       lastAppendWindowStart: null,
  818.       lastAppendWindowEnd: null,
  819.       restoreStreamAfterTrickPlay: null,
  820.       endOfStream: false,
  821.       performingUpdate: false,
  822.       updateTimer: null,
  823.       waitingToClearBuffer: false,
  824.       clearBufferSafeMargin: 0,
  825.       waitingToFlushBuffer: false,
  826.       clearingBuffer: false,
  827.       // The playhead might be seeking on startup, if a start time is set, so
  828.       // start "seeked" as true.
  829.       seeked: true,
  830.       recovering: false,
  831.       hasError: false,
  832.       operation: null,
  833.     });
  834.   }
  837.   /**
  838.    * Sets the MediaSource's duration.
  839.    */
  840.   updateDuration() {
  841.     const duration = this.manifest_.presentationTimeline.getDuration();
  842.     if (duration < Infinity) {
  843.       this.playerInterface_.mediaSourceEngine.setDuration(duration);
  844.     } else {
  845.       // Not all platforms support infinite durations, so set a finite duration
  846.       // so we can append segments and so the user agent can seek.
  847.       this.playerInterface_.mediaSourceEngine.setDuration(Math.pow(2, 32));
  848.     }
  849.   }
  852.   /**
  853.    * Called when |mediaState|'s update timer has expired.
  854.    *
  855.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  856.    * @suppress {suspiciousCode} The compiler assumes that updateTimer can't
  857.    *   change during the await, and so complains about the null check.
  858.    * @private
  859.    */
  860.   async onUpdate_(mediaState) {
  861.     this.destroyer_.ensureNotDestroyed();
  863.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  865.     // Sanity check.
  866.     goog.asserts.assert(
  867.         !mediaState.performingUpdate && (mediaState.updateTimer != null),
  868.         logPrefix + ' unexpected call to onUpdate_()');
  869.     if (mediaState.performingUpdate || (mediaState.updateTimer == null)) {
  870.       return;
  871.     }
  873.     goog.asserts.assert(
  874.         !mediaState.clearingBuffer, logPrefix +
  875.         ' onUpdate_() should not be called when clearing the buffer');
  876.     if (mediaState.clearingBuffer) {
  877.       return;
  878.     }
  880.     mediaState.updateTimer = null;
  882.     // Handle pending buffer clears.
  883.     if (mediaState.waitingToClearBuffer) {
  884.       // Note: clearBuffer_() will schedule the next update.
  885.       shaka.log.debug(logPrefix, 'skipping update and clearing the buffer');
  886.       await this.clearBuffer_(
  887.           mediaState, mediaState.waitingToFlushBuffer,
  888.           mediaState.clearBufferSafeMargin);
  889.       return;
  890.     }
  892.     // Make sure the segment index exists. If not, create the segment index.
  893.     if (!mediaState.stream.segmentIndex) {
  894.       const thisStream = mediaState.stream;
  896.       await mediaState.stream.createSegmentIndex();
  898.       if (thisStream != mediaState.stream) {
  899.         // We switched streams while in the middle of this async call to
  900.         // createSegmentIndex.  Abandon this update and schedule a new one if
  901.         // there's not already one pending.
  902.         // Releases the segmentIndex of the old stream.
  903.         if (thisStream.closeSegmentIndex) {
  904.           goog.asserts.assert(!mediaState.stream.segmentIndex,
  905.               'mediastate.stream should not have segmentIndex yet.');
  906.           thisStream.closeSegmentIndex();
  907.         }
  908.         if (mediaState.updateTimer == null) {
  909.           this.scheduleUpdate_(mediaState, 0);
  910.         }
  911.         return;
  912.       }
  913.     }
  915.     // Update the MediaState.
  916.     try {
  917.       const delay = this.update_(mediaState);
  918.       if (delay != null) {
  919.         this.scheduleUpdate_(mediaState, delay);
  920.         mediaState.hasError = false;
  921.       }
  922.     } catch (error) {
  923.       await this.handleStreamingError_(error);
  924.       return;
  925.     }
  927.     const mediaStates = Array.from(this.mediaStates_.values());
  929.     // Check if we've buffered to the end of the presentation.  We delay adding
  930.     // the audio and video media states, so it is possible for the text stream
  931.     // to be the only state and buffer to the end.  So we need to wait until we
  932.     // have completed startup to determine if we have reached the end.
  933.     if (this.startupComplete_ &&
  934.         mediaStates.every((ms) => ms.endOfStream)) {
  935.       shaka.log.v1(logPrefix, 'calling endOfStream()...');
  936.       await this.playerInterface_.mediaSourceEngine.endOfStream();
  937.       this.destroyer_.ensureNotDestroyed();
  939.       // If the media segments don't reach the end, then we need to update the
  940.       // timeline duration to match the final media duration to avoid
  941.       // buffering forever at the end.
  942.       // We should only do this if the duration needs to shrink.
  943.       // Growing it by less than 1ms can actually cause buffering on
  944.       // replay, as in https://github.com/shaka-project/shaka-player/issues/979
  945.       // On some platforms, this can spuriously be 0, so ignore this case.
  946.       // https://github.com/shaka-project/shaka-player/issues/1967,
  947.       const duration = this.playerInterface_.mediaSourceEngine.getDuration();
  948.       if (duration != 0 &&
  949.           duration < this.manifest_.presentationTimeline.getDuration()) {
  950.         this.manifest_.presentationTimeline.setDuration(duration);
  951.       }
  952.     }
  953.   }
  956.   /**
  957.    * Updates the given MediaState.
  958.    *
  959.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  960.    * @return {?number} The number of seconds to wait until updating again or
  961.    *   null if another update does not need to be scheduled.
  962.    * @private
  963.    */
  964.   update_(mediaState) {
  965.     goog.asserts.assert(this.manifest_, 'manifest_ should not be null');
  966.     goog.asserts.assert(this.config_, 'config_ should not be null');
  968.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  970.     // Do not schedule update for closed captions text mediastate, since closed
  971.     // captions are embedded in video streams.
  972.     if (shaka.media.StreamingEngine.isEmbeddedText_(mediaState)) {
  973.       this.playerInterface_.mediaSourceEngine.setSelectedClosedCaptionId(
  974.           mediaState.stream.originalId || '');
  975.       return null;
  976.     } else if (mediaState.type == ContentType.TEXT) {
  977.       // Disable embedded captions if not desired (e.g. if transitioning from
  978.       // embedded to not-embedded captions).
  979.       this.playerInterface_.mediaSourceEngine.clearSelectedClosedCaptionId();
  980.     }
  982.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  984.     // Compute how far we've buffered ahead of the playhead.
  985.     const presentationTime = this.playerInterface_.getPresentationTime();
  987.     // Get the next timestamp we need.
  988.     const timeNeeded = this.getTimeNeeded_(mediaState, presentationTime);
  989.     shaka.log.v2(logPrefix, 'timeNeeded=' + timeNeeded);
  991.     // Get the amount of content we have buffered, accounting for drift.  This
  992.     // is only used to determine if we have meet the buffering goal.  This
  993.     // should be the same method that PlayheadObserver uses.
  994.     const bufferedAhead =
  995.         this.playerInterface_.mediaSourceEngine.bufferedAheadOf(
  996.             mediaState.type, presentationTime);
  998.     shaka.log.v2(logPrefix,
  999.         'update_:',
  1000.         'presentationTime=' + presentationTime,
  1001.         'bufferedAhead=' + bufferedAhead);
  1003.     const unscaledBufferingGoal = Math.max(
  1004.         this.manifest_.minBufferTime || 0,
  1005.         this.config_.rebufferingGoal,
  1006.         this.config_.bufferingGoal);
  1008.     const scaledBufferingGoal =
  1009.         unscaledBufferingGoal * this.bufferingGoalScale_;
  1011.     // Check if we've buffered to the end of the presentation.
  1012.     const timeUntilEnd =
  1013.         this.manifest_.presentationTimeline.getDuration() - timeNeeded;
  1014.     const oneMicrosecond = 1e-6;
  1016.     const bufferEnd =
  1017.       this.playerInterface_.mediaSourceEngine.bufferEnd(mediaState.type);
  1019.     if (timeUntilEnd < oneMicrosecond && !!bufferEnd) {
  1020.       // We shouldn't rebuffer if the playhead is close to the end of the
  1021.       // presentation.
  1022.       shaka.log.debug(logPrefix, 'buffered to end of presentation');
  1023.       mediaState.endOfStream = true;
  1025.       if (mediaState.type == ContentType.VIDEO) {
  1026.         // Since the text stream of CEA closed captions doesn't have update
  1027.         // timer, we have to set the text endOfStream based on the video
  1028.         // stream's endOfStream state.
  1029.         const textState = this.mediaStates_.get(ContentType.TEXT);
  1030.         if (textState &&
  1031.             shaka.media.StreamingEngine.isEmbeddedText_(textState)) {
  1032.           textState.endOfStream = true;
  1033.         }
  1034.       }
  1035.       return null;
  1036.     }
  1037.     mediaState.endOfStream = false;
  1039.     // If we've buffered to the buffering goal then schedule an update.
  1040.     if (bufferedAhead >= scaledBufferingGoal) {
  1041.       shaka.log.v2(logPrefix, 'buffering goal met');
  1043.       // Do not try to predict the next update.  Just poll according to
  1044.       // configuration (seconds). The playback rate can change at any time, so
  1045.       // any prediction we make now could be terribly invalid soon.
  1046.       return this.config_.updateIntervalSeconds / 2;
  1047.     }
  1049.     const reference = this.getSegmentReferenceNeeded_(
  1050.         mediaState, presentationTime, bufferEnd);
  1051.     if (!reference) {
  1052.       // The segment could not be found, does not exist, or is not available.
  1053.       // In any case just try again... if the manifest is incomplete or is not
  1054.       // being updated then we'll idle forever; otherwise, we'll end up getting
  1055.       // a SegmentReference eventually.
  1056.       return this.config_.updateIntervalSeconds;
  1057.     }
  1059.     // Do not let any one stream get far ahead of any other.
  1060.     let minTimeNeeded = Infinity;
  1061.     const mediaStates = Array.from(this.mediaStates_.values());
  1062.     for (const otherState of mediaStates) {
  1063.       // Do not consider embedded captions in this calculation.  It could lead
  1064.       // to hangs in streaming.
  1065.       if (shaka.media.StreamingEngine.isEmbeddedText_(otherState)) {
  1066.         continue;
  1067.       }
  1068.       // If there is no next segment, ignore this stream.  This happens with
  1069.       // text when there's a Period with no text in it.
  1070.       if (otherState.segmentIterator && !otherState.segmentIterator.current()) {
  1071.         continue;
  1072.       }
  1074.       const timeNeeded = this.getTimeNeeded_(otherState, presentationTime);
  1075.       minTimeNeeded = Math.min(minTimeNeeded, timeNeeded);
  1076.     }
  1078.     const maxSegmentDuration =
  1079.         this.manifest_.presentationTimeline.getMaxSegmentDuration();
  1080.     const maxRunAhead = maxSegmentDuration *
  1081.         shaka.media.StreamingEngine.MAX_RUN_AHEAD_SEGMENTS_;
  1082.     if (timeNeeded >= minTimeNeeded + maxRunAhead) {
  1083.       // Wait and give other media types time to catch up to this one.
  1084.       // For example, let video buffering catch up to audio buffering before
  1085.       // fetching another audio segment.
  1086.       shaka.log.v2(logPrefix, 'waiting for other streams to buffer');
  1087.       return this.config_.updateIntervalSeconds;
  1088.     }
  1090.     const p = this.fetchAndAppend_(mediaState, presentationTime, reference);
  1091.     p.catch(() => {});  // TODO(#1993): Handle asynchronous errors.
  1092.     return null;
  1093.   }
  1096.   /**
  1097.    * Gets the next timestamp needed. Returns the playhead's position if the
  1098.    * buffer is empty; otherwise, returns the time at which the last segment
  1099.    * appended ends.
  1100.    *
  1101.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1102.    * @param {number} presentationTime
  1103.    * @return {number} The next timestamp needed.
  1104.    * @private
  1105.    */
  1106.   getTimeNeeded_(mediaState, presentationTime) {
  1107.     // Get the next timestamp we need. We must use |lastSegmentReference|
  1108.     // to determine this and not the actual buffer for two reasons:
  1109.     //   1. Actual segments end slightly before their advertised end times, so
  1110.     //      the next timestamp we need is actually larger than |bufferEnd|.
  1111.     //   2. There may be drift (the timestamps in the segments are ahead/behind
  1112.     //      of the timestamps in the manifest), but we need drift-free times
  1113.     //      when comparing times against the presentation timeline.
  1114.     if (!mediaState.lastSegmentReference) {
  1115.       return presentationTime;
  1116.     }
  1118.     return mediaState.lastSegmentReference.endTime;
  1119.   }
  1122.   /**
  1123.    * Gets the SegmentReference of the next segment needed.
  1124.    *
  1125.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1126.    * @param {number} presentationTime
  1127.    * @param {?number} bufferEnd
  1128.    * @return {shaka.media.SegmentReference} The SegmentReference of the
  1129.    *   next segment needed. Returns null if a segment could not be found, does
  1130.    *   not exist, or is not available.
  1131.    * @private
  1132.    */
  1133.   getSegmentReferenceNeeded_(mediaState, presentationTime, bufferEnd) {
  1134.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1135.     goog.asserts.assert(
  1136.         mediaState.stream.segmentIndex,
  1137.         'segment index should have been generated already');
  1139.     if (mediaState.segmentIterator) {
  1140.       // Something is buffered from the same Stream.  Use the current position
  1141.       // in the segment index.  This is updated via next() after each segment is
  1142.       // appended.
  1143.       return mediaState.segmentIterator.current();
  1144.     } else if (mediaState.lastSegmentReference || bufferEnd) {
  1145.       // Something is buffered from another Stream.
  1146.       const time = mediaState.lastSegmentReference ?
  1147.           mediaState.lastSegmentReference.endTime :
  1148.           bufferEnd;
  1149.       goog.asserts.assert(time != null, 'Should have a time to search');
  1150.       shaka.log.v1(
  1151.           logPrefix, 'looking up segment from new stream endTime:', time);
  1153.       mediaState.segmentIterator =
  1154.           mediaState.stream.segmentIndex.getIteratorForTime(time);
  1155.       const ref = mediaState.segmentIterator &&
  1156.           mediaState.segmentIterator.next().value;
  1157.       if (ref == null) {
  1158.         shaka.log.warning(logPrefix, 'cannot find segment', 'endTime:', time);
  1159.       }
  1160.       return ref;
  1161.     } else {
  1162.       // Nothing is buffered.  Start at the playhead time.
  1164.       // If there's positive drift then we need to adjust the lookup time, and
  1165.       // may wind up requesting the previous segment to be safe.
  1166.       // inaccurateManifestTolerance should be 0 for low latency streaming.
  1167.       const inaccurateTolerance = this.config_.inaccurateManifestTolerance;
  1168.       const lookupTime = Math.max(presentationTime - inaccurateTolerance, 0);
  1170.       shaka.log.v1(logPrefix, 'looking up segment',
  1171.           'lookupTime:', lookupTime,
  1172.           'presentationTime:', presentationTime);
  1174.       let ref = null;
  1175.       if (inaccurateTolerance) {
  1176.         mediaState.segmentIterator =
  1177.             mediaState.stream.segmentIndex.getIteratorForTime(lookupTime);
  1178.         ref = mediaState.segmentIterator &&
  1179.             mediaState.segmentIterator.next().value;
  1180.       }
  1181.       if (!ref) {
  1182.         // If we can't find a valid segment with the drifted time, look for a
  1183.         // segment with the presentation time.
  1184.         mediaState.segmentIterator =
  1185.             mediaState.stream.segmentIndex.getIteratorForTime(presentationTime);
  1186.         ref = mediaState.segmentIterator &&
  1187.             mediaState.segmentIterator.next().value;
  1188.       }
  1189.       if (ref == null) {
  1190.         shaka.log.warning(logPrefix, 'cannot find segment',
  1191.             'lookupTime:', lookupTime,
  1192.             'presentationTime:', presentationTime);
  1193.       }
  1194.       return ref;
  1195.     }
  1196.   }
  1199.   /**
  1200.    * Fetches and appends the given segment. Sets up the given MediaState's
  1201.    * associated SourceBuffer and evicts segments if either are required
  1202.    * beforehand. Schedules another update after completing successfully.
  1203.    *
  1204.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  1205.    * @param {number} presentationTime
  1206.    * @param {!shaka.media.SegmentReference} reference
  1207.    * @private
  1208.    */
  1209.   async fetchAndAppend_(mediaState, presentationTime, reference) {
  1210.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1211.     const StreamingEngine = shaka.media.StreamingEngine;
  1212.     const logPrefix = StreamingEngine.logPrefix_(mediaState);
  1214.     shaka.log.v1(logPrefix,
  1215.         'fetchAndAppend_:',
  1216.         'presentationTime=' + presentationTime,
  1217.         'reference.startTime=' + reference.startTime,
  1218.         'reference.endTime=' + reference.endTime);
  1220.     // Subtlety: The playhead may move while asynchronous update operations are
  1221.     // in progress, so we should avoid calling playhead.getTime() in any
  1222.     // callbacks. Furthermore, switch() or seeked() may be called at any time,
  1223.     // so we store the old iterator.  This allows the mediaState to change and
  1224.     // we'll update the old iterator.
  1225.     const stream = mediaState.stream;
  1226.     const iter = mediaState.segmentIterator;
  1228.     mediaState.performingUpdate = true;
  1230.     try {
  1231.       if (reference.getStatus() ==
  1232.           shaka.media.SegmentReference.Status.MISSING) {
  1233.         throw new shaka.util.Error(
  1234.             shaka.util.Error.Severity.RECOVERABLE,
  1235.             shaka.util.Error.Category.NETWORK,
  1236.             shaka.util.Error.Code.SEGMENT_MISSING);
  1237.       }
  1238.       await this.initSourceBuffer_(mediaState, reference);
  1239.       this.destroyer_.ensureNotDestroyed();
  1240.       if (this.fatalError_) {
  1241.         return;
  1242.       }
  1244.       shaka.log.v2(logPrefix, 'fetching segment');
  1245.       const isMP4 = stream.mimeType == 'video/mp4' ||
  1246.               stream.mimeType == 'audio/mp4';
  1247.       const isReadableStreamSupported = window.ReadableStream;
  1248.       // Enable MP4 low latency streaming with ReadableStream chunked data.
  1249.       if (this.config_.lowLatencyMode && isReadableStreamSupported && isMP4) {
  1250.         let remaining = new Uint8Array(0);
  1251.         let processingResult = false;
  1252.         let callbackCalled = false;
  1253.         const streamDataCallback = async (data) => {
  1254.           if (processingResult) {
  1255.             // If the fallback result processing was triggered, don't also
  1256.             // append the buffer here.  In theory this should never happen,
  1257.             // but it does on some older TVs.
  1258.             return;
  1259.           }
  1260.           callbackCalled = true;
  1261.           this.destroyer_.ensureNotDestroyed();
  1262.           if (this.fatalError_) {
  1263.             return;
  1264.           }
  1265.           // Append the data with complete boxes.
  1266.           // Every time streamDataCallback gets called, append the new data to
  1267.           // the remaining data.
  1268.           // Find the last fully completed Mdat box, and slice the data into two
  1269.           // parts: the first part with completed Mdat boxes, and the second
  1270.           // part with an incomplete box.
  1271.           // Append the first part, and save the second part as remaining data,
  1272.           // and handle it with the next streamDataCallback call.
  1273.           remaining = this.concatArray_(remaining, data);
  1274.           let sawMDAT = false;
  1275.           let offset = 0;
  1276.           new shaka.util.Mp4Parser()
  1277.               .box('mdat', (box) => {
  1278.                 offset = box.size + box.start;
  1279.                 sawMDAT = true;
  1280.               })
  1281.               .parse(remaining, /* partialOkay= */ false,
  1282.                   /* isChunkedData= */ true);
  1283.           if (sawMDAT) {
  1284.             const dataToAppend = remaining.subarray(0, offset);
  1285.             remaining = remaining.subarray(offset);
  1286.             await this.append_(
  1287.                 mediaState, presentationTime, stream, reference, dataToAppend);
  1288.           }
  1289.         };
  1291.         const result =
  1292.             await this.fetch_(mediaState, reference, streamDataCallback);
  1293.         if (!callbackCalled) {
  1294.           // In some environments, we might be forced to use network plugins
  1295.           // that don't support streamDataCallback. In those cases, as a
  1296.           // fallback, append the buffer here.
  1297.           processingResult = true;
  1298.           this.destroyer_.ensureNotDestroyed();
  1299.           if (this.fatalError_) {
  1300.             return;
  1301.           }
  1303.           // If the text stream gets switched between fetch_() and append_(),
  1304.           // the new text parser is initialized, but the new init segment is
  1305.           // not fetched yet.  That would cause an error in
  1306.           // TextParser.parseMedia().
  1307.           // See http://b/168253400
  1308.           if (mediaState.waitingToClearBuffer) {
  1309.             shaka.log.info(logPrefix, 'waitingToClearBuffer, skip append');
  1310.             mediaState.performingUpdate = false;
  1311.             this.scheduleUpdate_(mediaState, 0);
  1312.             return;
  1313.           }
  1315.           await this.append_(
  1316.               mediaState, presentationTime, stream, reference, result);
  1317.         }
  1318.       } else {
  1319.         if (this.config_.lowLatencyMode && !isReadableStreamSupported) {
  1320.           shaka.log.warning('Low latency streaming mode is enabled, but ' +
  1321.             'ReadableStream is not supported by the browser.');
  1322.         }
  1323.         const fetchSegment = this.fetch_(mediaState, reference);
  1324.         const result = await fetchSegment;
  1325.         this.destroyer_.ensureNotDestroyed();
  1326.         if (this.fatalError_) {
  1327.           return;
  1328.         }
  1330.         // If the text stream gets switched between fetch_() and append_(), the
  1331.         // new text parser is initialized, but the new init segment is not
  1332.         // fetched yet.  That would cause an error in TextParser.parseMedia().
  1333.         // See http://b/168253400
  1334.         if (mediaState.waitingToClearBuffer) {
  1335.           shaka.log.info(logPrefix, 'waitingToClearBuffer, skip append');
  1336.           mediaState.performingUpdate = false;
  1337.           this.scheduleUpdate_(mediaState, 0);
  1338.           return;
  1339.         }
  1341.         await this.append_(
  1342.             mediaState, presentationTime, stream, reference, result);
  1343.       }
  1345.       this.destroyer_.ensureNotDestroyed();
  1346.       if (this.fatalError_) {
  1347.         return;
  1348.       }
  1349.       // move to next segment after appending the current segment.
  1350.       mediaState.lastSegmentReference = reference;
  1351.       const newRef = iter.next().value;
  1352.       shaka.log.v2(logPrefix, 'advancing to next segment', newRef);
  1354.       mediaState.performingUpdate = false;
  1355.       mediaState.recovering = false;
  1357.       const info = this.playerInterface_.mediaSourceEngine.getBufferedInfo();
  1358.       const buffered = info[mediaState.type];
  1359.       // Convert the buffered object to a string capture its properties on
  1360.       // WebOS.
  1361.       shaka.log.v1(logPrefix, 'finished fetch and append',
  1362.           JSON.stringify(buffered));
  1364.       if (!mediaState.waitingToClearBuffer) {
  1365.         this.playerInterface_.onSegmentAppended();
  1366.       }
  1368.       // Update right away.
  1369.       this.scheduleUpdate_(mediaState, 0);
  1370.     } catch (error) {
  1371.       this.destroyer_.ensureNotDestroyed(error);
  1372.       if (this.fatalError_) {
  1373.         return;
  1374.       }
  1375.       goog.asserts.assert(error instanceof shaka.util.Error,
  1376.           'Should only receive a Shaka error');
  1378.       mediaState.performingUpdate = false;
  1380.       if (error.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  1381.         // If the network slows down, abort the current fetch request and start
  1382.         // a new one, and ignore the error message.
  1383.         mediaState.performingUpdate = false;
  1384.         mediaState.updateTimer = null;
  1385.         this.scheduleUpdate_(mediaState, 0);
  1386.       } else if (mediaState.type == ContentType.TEXT &&
  1387.           this.config_.ignoreTextStreamFailures) {
  1388.         if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS) {
  1389.           shaka.log.warning(logPrefix,
  1390.               'Text stream failed to download. Proceeding without it.');
  1391.         } else {
  1392.           shaka.log.warning(logPrefix,
  1393.               'Text stream failed to parse. Proceeding without it.');
  1394.         }
  1395.         this.mediaStates_.delete(ContentType.TEXT);
  1396.       } else if (error.code == shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR) {
  1397.         this.handleQuotaExceeded_(mediaState, error);
  1398.       } else {
  1399.         shaka.log.error(logPrefix, 'failed fetch and append: code=' +
  1400.             error.code);
  1401.         mediaState.hasError = true;
  1403.         error.severity = shaka.util.Error.Severity.CRITICAL;
  1404.         await this.handleStreamingError_(error);
  1405.       }
  1406.     }
  1407.   }
  1410.   /**
  1411.    * Clear per-stream error states and retry any failed streams.
  1412.    * @param {number} delaySeconds
  1413.    * @return {boolean} False if unable to retry.
  1414.    */
  1415.   retry(delaySeconds) {
  1416.     if (this.destroyer_.destroyed()) {
  1417.       shaka.log.error('Unable to retry after StreamingEngine is destroyed!');
  1418.       return false;
  1419.     }
  1421.     if (this.fatalError_) {
  1422.       shaka.log.error('Unable to retry after StreamingEngine encountered a ' +
  1423.                       'fatal error!');
  1424.       return false;
  1425.     }
  1427.     for (const mediaState of this.mediaStates_.values()) {
  1428.       const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1429.       if (mediaState.hasError) {
  1430.         shaka.log.info(logPrefix, 'Retrying after failure...');
  1431.         mediaState.hasError = false;
  1432.         this.scheduleUpdate_(mediaState, delaySeconds);
  1433.       }
  1434.     }
  1436.     return true;
  1437.   }
  1440.   /**
  1441.    * Append the data to the remaining data.
  1442.    * @param {!Uint8Array} remaining
  1443.    * @param {!Uint8Array} data
  1444.    * @return {!Uint8Array}
  1445.    * @private
  1446.    */
  1447.   concatArray_(remaining, data) {
  1448.     const result = new Uint8Array(remaining.length + data.length);
  1449.     result.set(remaining);
  1450.     result.set(data, remaining.length);
  1451.     return result;
  1452.   }
  1455.   /**
  1456.    * Handles a QUOTA_EXCEEDED_ERROR.
  1457.    *
  1458.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1459.    * @param {!shaka.util.Error} error
  1460.    * @private
  1461.    */
  1462.   handleQuotaExceeded_(mediaState, error) {
  1463.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1465.     // The segment cannot fit into the SourceBuffer. Ideally, MediaSource would
  1466.     // have evicted old data to accommodate the segment; however, it may have
  1467.     // failed to do this if the segment is very large, or if it could not find
  1468.     // a suitable time range to remove.
  1469.     //
  1470.     // We can overcome the latter by trying to append the segment again;
  1471.     // however, to avoid continuous QuotaExceededErrors we must reduce the size
  1472.     // of the buffer going forward.
  1473.     //
  1474.     // If we've recently reduced the buffering goals, wait until the stream
  1475.     // which caused the first QuotaExceededError recovers. Doing this ensures
  1476.     // we don't reduce the buffering goals too quickly.
  1478.     const mediaStates = Array.from(this.mediaStates_.values());
  1479.     const waitingForAnotherStreamToRecover = mediaStates.some((ms) => {
  1480.       return ms != mediaState && ms.recovering;
  1481.     });
  1483.     if (!waitingForAnotherStreamToRecover) {
  1484.       // Reduction schedule: 80%, 60%, 40%, 20%, 16%, 12%, 8%, 4%, fail.
  1485.       // Note: percentages are used for comparisons to avoid rounding errors.
  1486.       const percentBefore = Math.round(100 * this.bufferingGoalScale_);
  1487.       if (percentBefore > 20) {
  1488.         this.bufferingGoalScale_ -= 0.2;
  1489.       } else if (percentBefore > 4) {
  1490.         this.bufferingGoalScale_ -= 0.04;
  1491.       } else {
  1492.         shaka.log.error(
  1493.             logPrefix, 'MediaSource threw QuotaExceededError too many times');
  1494.         mediaState.hasError = true;
  1495.         this.fatalError_ = true;
  1496.         this.playerInterface_.onError(error);
  1497.         return;
  1498.       }
  1499.       const percentAfter = Math.round(100 * this.bufferingGoalScale_);
  1500.       shaka.log.warning(
  1501.           logPrefix,
  1502.           'MediaSource threw QuotaExceededError:',
  1503.           'reducing buffering goals by ' + (100 - percentAfter) + '%');
  1504.       mediaState.recovering = true;
  1505.     } else {
  1506.       shaka.log.debug(
  1507.           logPrefix,
  1508.           'MediaSource threw QuotaExceededError:',
  1509.           'waiting for another stream to recover...');
  1510.     }
  1512.     // QuotaExceededError gets thrown if evication didn't help to make room
  1513.     // for a segment. We want to wait for a while (4 seconds is just an
  1514.     // arbitrary number) before updating to give the playhead a chance to
  1515.     // advance, so we don't immidiately throw again.
  1516.     this.scheduleUpdate_(mediaState, 4);
  1517.   }
  1520.   /**
  1521.    * Sets the given MediaState's associated SourceBuffer's timestamp offset,
  1522.    * append window, and init segment if they have changed. If an error occurs
  1523.    * then neither the timestamp offset or init segment are unset, since another
  1524.    * call to switch() will end up superseding them.
  1525.    *
  1526.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1527.    * @param {!shaka.media.SegmentReference} reference
  1528.    * @return {!Promise}
  1529.    * @private
  1530.    */
  1531.   async initSourceBuffer_(mediaState, reference) {
  1532.     const StreamingEngine = shaka.media.StreamingEngine;
  1533.     const logPrefix = StreamingEngine.logPrefix_(mediaState);
  1535.     /** @type {!Array.<!Promise>} */
  1536.     const operations = [];
  1538.     // Rounding issues can cause us to remove the first frame of a Period, so
  1539.     // reduce the window start time slightly.
  1540.     const appendWindowStart = Math.max(0,
  1541.         reference.appendWindowStart -
  1542.         StreamingEngine.APPEND_WINDOW_START_FUDGE_);
  1543.     const appendWindowEnd =
  1544.         reference.appendWindowEnd + StreamingEngine.APPEND_WINDOW_END_FUDGE_;
  1546.     goog.asserts.assert(
  1547.         reference.startTime <= appendWindowEnd,
  1548.         logPrefix + ' segment should start before append window end');
  1550.     const timestampOffset = reference.timestampOffset;
  1551.     if (timestampOffset != mediaState.lastTimestampOffset ||
  1552.         appendWindowStart != mediaState.lastAppendWindowStart ||
  1553.         appendWindowEnd != mediaState.lastAppendWindowEnd) {
  1554.       shaka.log.v1(logPrefix, 'setting timestamp offset to ' + timestampOffset);
  1555.       shaka.log.v1(logPrefix,
  1556.           'setting append window start to ' + appendWindowStart);
  1557.       shaka.log.v1(logPrefix,
  1558.           'setting append window end to ' + appendWindowEnd);
  1560.       const setProperties = async () => {
  1561.         try {
  1562.           mediaState.lastAppendWindowStart = appendWindowStart;
  1563.           mediaState.lastAppendWindowEnd = appendWindowEnd;
  1564.           mediaState.lastTimestampOffset = timestampOffset;
  1566.           await this.playerInterface_.mediaSourceEngine.setStreamProperties(
  1567.               mediaState.type, timestampOffset, appendWindowStart,
  1568.               appendWindowEnd, this.manifest_.sequenceMode);
  1569.         } catch (error) {
  1570.           mediaState.lastAppendWindowStart = null;
  1571.           mediaState.lastAppendWindowEnd = null;
  1572.           mediaState.lastTimestampOffset = null;
  1574.           throw error;
  1575.         }
  1576.       };
  1577.       operations.push(setProperties());
  1578.     }
  1580.     if (!shaka.media.InitSegmentReference.equal(
  1581.         reference.initSegmentReference, mediaState.lastInitSegmentReference)) {
  1582.       mediaState.lastInitSegmentReference = reference.initSegmentReference;
  1584.       if (reference.initSegmentReference) {
  1585.         shaka.log.v1(logPrefix, 'fetching init segment');
  1587.         const fetchInit =
  1588.             this.fetch_(mediaState, reference.initSegmentReference);
  1589.         const append = async () => {
  1590.           try {
  1591.             const initSegment = await fetchInit;
  1592.             this.destroyer_.ensureNotDestroyed();
  1593.             shaka.log.v1(logPrefix, 'appending init segment');
  1594.             const hasClosedCaptions = mediaState.stream.closedCaptions &&
  1595.                 mediaState.stream.closedCaptions.size > 0;
  1596.             await this.playerInterface_.beforeAppendSegment(
  1597.                 mediaState.type, initSegment);
  1598.             await this.playerInterface_.mediaSourceEngine.appendBuffer(
  1599.                 mediaState.type, initSegment, /* reference= */ null,
  1600.                 hasClosedCaptions);
  1601.           } catch (error) {
  1602.             mediaState.lastInitSegmentReference = null;
  1603.             throw error;
  1604.           }
  1605.         };
  1606.         this.playerInterface_.onInitSegmentAppended(
  1607.             reference.startTime, reference.initSegmentReference);
  1608.         operations.push(append());
  1609.       }
  1610.     }
  1612.     await Promise.all(operations);
  1613.   }
  1616.   /**
  1617.    * Appends the given segment and evicts content if required to append.
  1618.    *
  1619.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  1620.    * @param {number} presentationTime
  1621.    * @param {shaka.extern.Stream} stream
  1622.    * @param {!shaka.media.SegmentReference} reference
  1623.    * @param {BufferSource} segment
  1624.    * @return {!Promise}
  1625.    * @private
  1626.    */
  1627.   async append_(mediaState, presentationTime, stream, reference, segment) {
  1628.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1630.     const hasClosedCaptions = stream.closedCaptions &&
  1631.         stream.closedCaptions.size > 0;
  1632.     if ((stream.emsgSchemeIdUris != null &&
  1633.         stream.emsgSchemeIdUris.length > 0) ||
  1634.         this.config_.dispatchAllEmsgBoxes) {
  1635.       new shaka.util.Mp4Parser()
  1636.           .fullBox(
  1637.               'emsg',
  1638.               (box) => this.parseEMSG_(
  1639.                   reference, stream.emsgSchemeIdUris, box))
  1640.           .parse(segment);
  1641.     }
  1643.     await this.evict_(mediaState, presentationTime);
  1644.     this.destroyer_.ensureNotDestroyed();
  1645.     shaka.log.v1(logPrefix, 'appending media segment at',
  1646.         (reference.syncTime == null ? 'unknown' : reference.syncTime));
  1648.     // 'seeked' or 'adaptation' triggered logic applies only to this
  1649.     // appendBuffer() call.
  1650.     const seeked = mediaState.seeked;
  1651.     mediaState.seeked = false;
  1652.     const adaptation = mediaState.adaptation;
  1653.     mediaState.adaptation = false;
  1655.     await this.playerInterface_.beforeAppendSegment(mediaState.type, segment);
  1656.     await this.playerInterface_.mediaSourceEngine.appendBuffer(
  1657.         mediaState.type,
  1658.         segment,
  1659.         reference,
  1660.         hasClosedCaptions,
  1661.         seeked,
  1662.         adaptation);
  1663.     this.destroyer_.ensureNotDestroyed();
  1664.     shaka.log.v2(logPrefix, 'appended media segment');
  1665.   }
  1668.   /**
  1669.    * Parse the EMSG box from a MP4 container.
  1670.    *
  1671.    * @param {!shaka.media.SegmentReference} reference
  1672.    * @param {?Array.<string>} emsgSchemeIdUris Array of emsg
  1673.    *     scheme_id_uri for which emsg boxes should be parsed.
  1674.    * @param {!shaka.extern.ParsedBox} box
  1675.    * @private
  1676.    * https://dashif-documents.azurewebsites.net/Events/master/event.html#emsg-format
  1677.    * aligned(8) class DASHEventMessageBox
  1678.    *    extends FullBox(‘emsg’, version, flags = 0){
  1679.    * if (version==0) {
  1680.    *   string scheme_id_uri;
  1681.    *   string value;
  1682.    *   unsigned int(32) timescale;
  1683.    *   unsigned int(32) presentation_time_delta;
  1684.    *   unsigned int(32) event_duration;
  1685.    *   unsigned int(32) id;
  1686.    * } else if (version==1) {
  1687.    *   unsigned int(32) timescale;
  1688.    *   unsigned int(64) presentation_time;
  1689.    *   unsigned int(32) event_duration;
  1690.    *   unsigned int(32) id;
  1691.    *   string scheme_id_uri;
  1692.    *   string value;
  1693.    * }
  1694.    * unsigned int(8) message_data[];
  1695.    */
  1696.   parseEMSG_(reference, emsgSchemeIdUris, box) {
  1697.     let timescale;
  1698.     let id;
  1699.     let eventDuration;
  1700.     let schemeId;
  1701.     let startTime;
  1702.     let presentationTimeDelta;
  1703.     let value;
  1705.     if (box.version === 0) {
  1706.       schemeId = box.reader.readTerminatedString();
  1707.       value = box.reader.readTerminatedString();
  1708.       timescale = box.reader.readUint32();
  1709.       presentationTimeDelta = box.reader.readUint32();
  1710.       eventDuration = box.reader.readUint32();
  1711.       id = box.reader.readUint32();
  1712.       startTime = reference.startTime + (presentationTimeDelta / timescale);
  1713.     } else {
  1714.       timescale = box.reader.readUint32();
  1715.       const pts = box.reader.readUint64();
  1716.       startTime = (pts / timescale) + reference.timestampOffset;
  1717.       presentationTimeDelta = startTime - reference.startTime;
  1718.       eventDuration = box.reader.readUint32();
  1719.       id = box.reader.readUint32();
  1720.       schemeId = box.reader.readTerminatedString();
  1721.       value = box.reader.readTerminatedString();
  1722.     }
  1723.     const messageData = box.reader.readBytes(
  1724.         box.reader.getLength() - box.reader.getPosition());
  1727.     // See DASH sec. 5.10.3.3.1
  1728.     // If a DASH client detects an event message box with a scheme that is not
  1729.     // defined in MPD, the client is expected to ignore it.
  1730.     if ((emsgSchemeIdUris && emsgSchemeIdUris.includes(schemeId)) ||
  1731.         this.config_.dispatchAllEmsgBoxes) {
  1732.       // See DASH sec. 5.10.4.1
  1733.       // A special scheme in DASH used to signal manifest updates.
  1734.       if (schemeId == 'urn:mpeg:dash:event:2012') {
  1735.         this.playerInterface_.onManifestUpdate();
  1736.       } else {
  1737.         /** @type {shaka.extern.EmsgInfo} */
  1738.         const emsg = {
  1739.           startTime: startTime,
  1740.           endTime: startTime + (eventDuration / timescale),
  1741.           schemeIdUri: schemeId,
  1742.           value: value,
  1743.           timescale: timescale,
  1744.           presentationTimeDelta: presentationTimeDelta,
  1745.           eventDuration: eventDuration,
  1746.           id: id,
  1747.           messageData: messageData,
  1748.         };
  1750.         // Dispatch an event to notify the application about the emsg box.
  1751.         const eventName = shaka.util.FakeEvent.EventName.Emsg;
  1752.         const data = (new Map()).set('detail', emsg);
  1753.         const event = new shaka.util.FakeEvent(eventName, data);
  1754.         this.playerInterface_.onEvent(event);
  1755.       }
  1756.     }
  1757.   }
  1760.   /**
  1761.    * Evicts media to meet the max buffer behind limit.
  1762.    *
  1763.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1764.    * @param {number} presentationTime
  1765.    * @private
  1766.    */
  1767.   async evict_(mediaState, presentationTime) {
  1768.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1769.     shaka.log.v2(logPrefix, 'checking buffer length');
  1771.     // Use the max segment duration, if it is longer than the bufferBehind, to
  1772.     // avoid accidentally clearing too much data when dealing with a manifest
  1773.     // with a long keyframe interval.
  1774.     const bufferBehind = Math.max(this.config_.bufferBehind,
  1775.         this.manifest_.presentationTimeline.getMaxSegmentDuration());
  1777.     const startTime =
  1778.         this.playerInterface_.mediaSourceEngine.bufferStart(mediaState.type);
  1779.     if (startTime == null) {
  1780.       shaka.log.v2(logPrefix,
  1781.           'buffer behind okay because nothing buffered:',
  1782.           'presentationTime=' + presentationTime,
  1783.           'bufferBehind=' + bufferBehind);
  1784.       return;
  1785.     }
  1786.     const bufferedBehind = presentationTime - startTime;
  1788.     const overflow = bufferedBehind - bufferBehind;
  1789.     // See: https://github.com/shaka-project/shaka-player/issues/2982
  1790.     if (overflow <= 0.01) {
  1791.       shaka.log.v2(logPrefix,
  1792.           'buffer behind okay:',
  1793.           'presentationTime=' + presentationTime,
  1794.           'bufferedBehind=' + bufferedBehind,
  1795.           'bufferBehind=' + bufferBehind,
  1796.           'underflow=' + Math.abs(overflow));
  1797.       return;
  1798.     }
  1800.     shaka.log.v1(logPrefix,
  1801.         'buffer behind too large:',
  1802.         'presentationTime=' + presentationTime,
  1803.         'bufferedBehind=' + bufferedBehind,
  1804.         'bufferBehind=' + bufferBehind,
  1805.         'overflow=' + overflow);
  1807.     await this.playerInterface_.mediaSourceEngine.remove(mediaState.type,
  1808.         startTime, startTime + overflow);
  1810.     this.destroyer_.ensureNotDestroyed();
  1811.     shaka.log.v1(logPrefix, 'evicted ' + overflow + ' seconds');
  1812.   }
  1815.   /**
  1816.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1817.    * @return {boolean}
  1818.    * @private
  1819.    */
  1820.   static isEmbeddedText_(mediaState) {
  1821.     const MimeUtils = shaka.util.MimeUtils;
  1822.     const CEA608_MIME = MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE;
  1823.     const CEA708_MIME = MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE;
  1824.     return mediaState &&
  1825.         mediaState.type == shaka.util.ManifestParserUtils.ContentType.TEXT &&
  1826.         (mediaState.stream.mimeType == CEA608_MIME ||
  1827.          mediaState.stream.mimeType == CEA708_MIME);
  1828.   }
  1831.   /**
  1832.    * Fetches the given segment.
  1833.    *
  1834.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  1835.    * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
  1836.    *   reference
  1837.    * @param {?function(BufferSource):!Promise=} streamDataCallback
  1838.    *
  1839.    * @return {!Promise.<BufferSource>}
  1840.    * @private
  1841.    * @suppress {strictMissingProperties}
  1842.    */
  1843.   async fetch_(mediaState, reference, streamDataCallback) {
  1844.     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1846.     const request = shaka.util.Networking.createSegmentRequest(
  1847.         reference.getUris(),
  1848.         reference.startByte,
  1849.         reference.endByte,
  1850.         this.config_.retryParameters,
  1851.         streamDataCallback);
  1853.     shaka.log.v2('fetching: reference=', reference);
  1855.     const stream = mediaState.stream;
  1856.     this.playerInterface_.modifySegmentRequest(
  1857.         request,
  1858.         {
  1859.           type: stream.type,
  1860.           init: reference instanceof shaka.media.InitSegmentReference,
  1861.           duration: reference.endTime - reference.startTime,
  1862.           mimeType: stream.mimeType,
  1863.           codecs: stream.codecs,
  1864.           bandwidth: stream.bandwidth,
  1865.         },
  1866.     );
  1868.     const op = this.playerInterface_.netEngine.request(requestType, request);
  1869.     mediaState.operation = op;
  1870.     const response = await op.promise;
  1871.     mediaState.operation = null;
  1872.     return response.data;
  1873.   }
  1876.   /**
  1877.    * Clears the buffer and schedules another update.
  1878.    * The optional parameter safeMargin allows to retain a certain amount
  1879.    * of buffer, which can help avoiding rebuffering events.
  1880.    * The value of the safe margin should be provided by the ABR manager.
  1881.    *
  1882.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  1883.    * @param {boolean} flush
  1884.    * @param {number} safeMargin
  1885.    * @private
  1886.    */
  1887.   async clearBuffer_(mediaState, flush, safeMargin) {
  1888.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1890.     goog.asserts.assert(
  1891.         !mediaState.performingUpdate && (mediaState.updateTimer == null),
  1892.         logPrefix + ' unexpected call to clearBuffer_()');
  1894.     mediaState.waitingToClearBuffer = false;
  1895.     mediaState.waitingToFlushBuffer = false;
  1896.     mediaState.clearBufferSafeMargin = 0;
  1897.     mediaState.clearingBuffer = true;
  1898.     mediaState.lastSegmentReference = null;
  1899.     mediaState.lastInitSegmentReference = null;
  1900.     mediaState.segmentIterator = null;
  1902.     shaka.log.debug(logPrefix, 'clearing buffer');
  1904.     if (safeMargin) {
  1905.       const presentationTime = this.playerInterface_.getPresentationTime();
  1906.       const duration = this.playerInterface_.mediaSourceEngine.getDuration();
  1907.       await this.playerInterface_.mediaSourceEngine.remove(
  1908.           mediaState.type, presentationTime + safeMargin, duration);
  1909.     } else {
  1910.       await this.playerInterface_.mediaSourceEngine.clear(mediaState.type);
  1911.       this.destroyer_.ensureNotDestroyed();
  1913.       if (flush) {
  1914.         await this.playerInterface_.mediaSourceEngine.flush(
  1915.             mediaState.type);
  1916.       }
  1917.     }
  1918.     this.destroyer_.ensureNotDestroyed();
  1920.     shaka.log.debug(logPrefix, 'cleared buffer');
  1921.     mediaState.clearingBuffer = false;
  1922.     mediaState.endOfStream = false;
  1923.     this.scheduleUpdate_(mediaState, 0);
  1924.   }
  1927.   /**
  1928.    * Schedules |mediaState|'s next update.
  1929.    *
  1930.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  1931.    * @param {number} delay The delay in seconds.
  1932.    * @private
  1933.    */
  1934.   scheduleUpdate_(mediaState, delay) {
  1935.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1937.     // If the text's update is canceled and its mediaState is deleted, stop
  1938.     // scheduling another update.
  1939.     const type = mediaState.type;
  1940.     if (type == shaka.util.ManifestParserUtils.ContentType.TEXT &&
  1941.           !this.mediaStates_.has(type)) {
  1942.       shaka.log.v1(logPrefix, 'Text stream is unloaded. No update is needed.');
  1943.       return;
  1944.     }
  1946.     shaka.log.v2(logPrefix, 'updating in ' + delay + ' seconds');
  1947.     goog.asserts.assert(mediaState.updateTimer == null,
  1948.         logPrefix + ' did not expect update to be scheduled');
  1950.     mediaState.updateTimer = new shaka.util.DelayedTick(async () => {
  1951.       try {
  1952.         await this.onUpdate_(mediaState);
  1953.       } catch (error) {
  1954.         if (this.playerInterface_) {
  1955.           this.playerInterface_.onError(error);
  1956.         }
  1957.       }
  1958.     }).tickAfter(delay);
  1959.   }
  1962.   /**
  1963.    * If |mediaState| is scheduled to update, stop it.
  1964.    *
  1965.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1966.    * @private
  1967.    */
  1968.   cancelUpdate_(mediaState) {
  1969.     if (mediaState.updateTimer == null) {
  1970.       return;
  1971.     }
  1973.     mediaState.updateTimer.stop();
  1974.     mediaState.updateTimer = null;
  1975.   }
  1978.   /**
  1979.    * If |mediaState| holds any in-progress operations, abort them.
  1980.    *
  1981.    * @return {!Promise}
  1982.    * @private
  1983.    */
  1984.   async abortOperations_(mediaState) {
  1985.     if (mediaState.operation) {
  1986.       await mediaState.operation.abort();
  1987.     }
  1988.   }
  1990.   /**
  1991.    * Handle streaming errors by delaying, then notifying the application by
  1992.    * error callback and by streaming failure callback.
  1993.    *
  1994.    * @param {!shaka.util.Error} error
  1995.    * @return {!Promise}
  1996.    * @private
  1997.    */
  1998.   async handleStreamingError_(error) {
  1999.     // If we invoke the callback right away, the application could trigger a
  2000.     // rapid retry cycle that could be very unkind to the server.  Instead,
  2001.     // use the backoff system to delay and backoff the error handling.
  2002.     await this.failureCallbackBackoff_.attempt();
  2003.     this.destroyer_.ensureNotDestroyed();
  2005.     // First fire an error event.
  2006.     this.playerInterface_.onError(error);
  2008.     // If the error was not handled by the application, call the failure
  2009.     // callback.
  2010.     if (!error.handled) {
  2011.       this.config_.failureCallback(error);
  2012.     }
  2013.   }
  2015.   /**
  2016.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  2017.    * @return {string} A log prefix of the form ($CONTENT_TYPE:$STREAM_ID), e.g.,
  2018.    *   "(audio:5)" or "(video:hd)".
  2019.    * @private
  2020.    */
  2021.   static logPrefix_(mediaState) {
  2022.     return '(' + mediaState.type + ':' + mediaState.stream.id + ')';
  2023.   }
  2024. };
  2027. /**
  2028.  * @typedef {{
  2029.  *   getPresentationTime: function():number,
  2030.  *   getBandwidthEstimate: function():number,
  2031.  *   modifySegmentRequest: function(shaka.extern.Request,
  2032.  *     shaka.util.CmcdManager.SegmentInfo),
  2033.  *   mediaSourceEngine: !shaka.media.MediaSourceEngine,
  2034.  *   netEngine: shaka.net.NetworkingEngine,
  2035.  *   onError: function(!shaka.util.Error),
  2036.  *   onEvent: function(!Event),
  2037.  *   onManifestUpdate: function(),
  2038.  *   onSegmentAppended: function(),
  2039.  *   onInitSegmentAppended: function(!number,!shaka.media.InitSegmentReference),
  2040.  *   beforeAppendSegment: function(
  2041.  *     shaka.util.ManifestParserUtils.ContentType,!BufferSource):Promise
  2042.  * }}
  2043.  *
  2044.  * @property {function():number} getPresentationTime
  2045.  *   Get the position in the presentation (in seconds) of the content that the
  2046.  *   viewer is seeing on screen right now.
  2047.  * @property {function():number} getBandwidthEstimate
  2048.  *   Get the estimated bandwidth in bits per second.
  2049.  * @property {function(shaka.extern.Request,
  2050.  *   shaka.extern.Cmcd.SegmentInfo)} modifySegmentRequest
  2051.  *   The request modifier
  2052.  * @property {!shaka.media.MediaSourceEngine} mediaSourceEngine
  2053.  *   The MediaSourceEngine. The caller retains ownership.
  2054.  * @property {shaka.net.NetworkingEngine} netEngine
  2055.  *   The NetworkingEngine instance to use. The caller retains ownership.
  2056.  * @property {function(!shaka.util.Error)} onError
  2057.  *   Called when an error occurs. If the error is recoverable (see
  2058.  *   {@link shaka.util.Error}) then the caller may invoke either
  2059.  *   StreamingEngine.switch*() or StreamingEngine.seeked() to attempt recovery.
  2060.  * @property {function(!Event)} onEvent
  2061.  *   Called when an event occurs that should be sent to the app.
  2062.  * @property {function()} onManifestUpdate
  2063.  *   Called when an embedded 'emsg' box should trigger a manifest update.
  2064.  * @property {function()} onSegmentAppended
  2065.  *   Called after a segment is successfully appended to a MediaSource.
  2066.  * @property
  2067.  *  {function(!number, !shaka.media.InitSegmentReference)} onInitSegmentAppended
  2068.  *   Called when an init segment is appended to a MediaSource.
  2069.  * @property {!function(shaka.util.ManifestParserUtils.ContentType,
  2070.  *   !BufferSource):Promise} beforeAppendSegment
  2071.  *   A function called just before appending to the source buffer.
  2072.  */
  2073. shaka.media.StreamingEngine.PlayerInterface;
  2076. /**
  2077.  * @typedef {{
  2078.  *   type: shaka.util.ManifestParserUtils.ContentType,
  2079.  *   stream: shaka.extern.Stream,
  2080.  *   segmentIterator: shaka.media.SegmentIterator,
  2081.  *   lastSegmentReference: shaka.media.SegmentReference,
  2082.  *   lastInitSegmentReference: shaka.media.InitSegmentReference,
  2083.  *   lastTimestampOffset: ?number,
  2084.  *   lastAppendWindowStart: ?number,
  2085.  *   lastAppendWindowEnd: ?number,
  2086.  *   restoreStreamAfterTrickPlay: ?shaka.extern.Stream,
  2087.  *   endOfStream: boolean,
  2088.  *   performingUpdate: boolean,
  2089.  *   updateTimer: shaka.util.DelayedTick,
  2090.  *   waitingToClearBuffer: boolean,
  2091.  *   waitingToFlushBuffer: boolean,
  2092.  *   clearBufferSafeMargin: number,
  2093.  *   clearingBuffer: boolean,
  2094.  *   seeked: boolean,
  2095.  *   adaptation: boolean,
  2096.  *   recovering: boolean,
  2097.  *   hasError: boolean,
  2098.  *   operation: shaka.net.NetworkingEngine.PendingRequest
  2099.  * }}
  2100.  *
  2101.  * @description
  2102.  * Contains the state of a logical stream, i.e., a sequence of segmented data
  2103.  * for a particular content type. At any given time there is a Stream object
  2104.  * associated with the state of the logical stream.
  2105.  *
  2106.  * @property {shaka.util.ManifestParserUtils.ContentType} type
  2107.  *   The stream's content type, e.g., 'audio', 'video', or 'text'.
  2108.  * @property {shaka.extern.Stream} stream
  2109.  *   The current Stream.
  2110.  * @property {shaka.media.SegmentIndexIterator} segmentIterator
  2111.  *   An iterator through the segments of |stream|.
  2112.  * @property {shaka.media.SegmentReference} lastSegmentReference
  2113.  *   The SegmentReference of the last segment that was appended.
  2114.  * @property {shaka.media.InitSegmentReference} lastInitSegmentReference
  2115.  *   The InitSegmentReference of the last init segment that was appended.
  2116.  * @property {?number} lastTimestampOffset
  2117.  *   The last timestamp offset given to MediaSourceEngine for this type.
  2118.  * @property {?number} lastAppendWindowStart
  2119.  *   The last append window start given to MediaSourceEngine for this type.
  2120.  * @property {?number} lastAppendWindowEnd
  2121.  *   The last append window end given to MediaSourceEngine for this type.
  2122.  * @property {?shaka.extern.Stream} restoreStreamAfterTrickPlay
  2123.  *   The Stream to restore after trick play mode is turned off.
  2124.  * @property {boolean} endOfStream
  2125.  *   True indicates that the end of the buffer has hit the end of the
  2126.  *   presentation.
  2127.  * @property {boolean} performingUpdate
  2128.  *   True indicates that an update is in progress.
  2129.  * @property {shaka.util.DelayedTick} updateTimer
  2130.  *   A timer used to update the media state.
  2131.  * @property {boolean} waitingToClearBuffer
  2132.  *   True indicates that the buffer must be cleared after the current update
  2133.  *   finishes.
  2134.  * @property {boolean} waitingToFlushBuffer
  2135.  *   True indicates that the buffer must be flushed after it is cleared.
  2136.  * @property {number} clearBufferSafeMargin
  2137.  *   The amount of buffer to retain when clearing the buffer after the update.
  2138.  * @property {boolean} clearingBuffer
  2139.  *   True indicates that the buffer is being cleared.
  2140.   * @property {boolean} seeked
  2141.  *   True indicates that the presentation just seeked.
  2142.   * @property {boolean} adaptation
  2143.  *   True indicates that the presentation just automatically switched variants.
  2144.  * @property {boolean} recovering
  2145.  *   True indicates that the last segment was not appended because it could not
  2146.  *   fit in the buffer.
  2147.  * @property {boolean} hasError
  2148.  *   True indicates that the stream has encountered an error and has stopped
  2149.  *   updating.
  2150.  * @property {shaka.net.NetworkingEngine.PendingRequest} operation
  2151.  *   Operation with the number of bytes to be downloaded.
  2152.  */
  2153. shaka.media.StreamingEngine.MediaState_;
  2156. /**
  2157.  * The fudge factor for appendWindowStart.  By adjusting the window backward, we
  2158.  * avoid rounding errors that could cause us to remove the keyframe at the start
  2159.  * of the Period.
  2160.  *
  2161.  * NOTE: This was increased as part of the solution to
  2162.  * https://github.com/shaka-project/shaka-player/issues/1281
  2163.  *
  2164.  * @const {number}
  2165.  * @private
  2166.  */
  2167. shaka.media.StreamingEngine.APPEND_WINDOW_START_FUDGE_ = 0.1;
  2170. /**
  2171.  * The fudge factor for appendWindowEnd.  By adjusting the window backward, we
  2172.  * avoid rounding errors that could cause us to remove the last few samples of
  2173.  * the Period.  This rounding error could then create an artificial gap and a
  2174.  * stutter when the gap-jumping logic takes over.
  2175.  *
  2176.  * https://github.com/shaka-project/shaka-player/issues/1597
  2177.  *
  2178.  * @const {number}
  2179.  * @private
  2180.  */
  2181. shaka.media.StreamingEngine.APPEND_WINDOW_END_FUDGE_ = 0.01;
  2184. /**
  2185.  * The maximum number of segments by which a stream can get ahead of other
  2186.  * streams.
  2187.  *
  2188.  * Introduced to keep StreamingEngine from letting one media type get too far
  2189.  * ahead of another.  For example, audio segments are typically much smaller
  2190.  * than video segments, so in the time it takes to fetch one video segment, we
  2191.  * could fetch many audio segments.  This doesn't help with buffering, though,
  2192.  * since the intersection of the two buffered ranges is what counts.
  2193.  *
  2194.  * @const {number}
  2195.  * @private
  2196.  */
  2197. shaka.media.StreamingEngine.MAX_RUN_AHEAD_SEGMENTS_ = 1;