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.  */
  11. goog.provide('shaka.media.StreamingEngine');
  13. goog.require('goog.asserts');
  14. goog.require('shaka.log');
  15. goog.require('shaka.media.InitSegmentReference');
  16. goog.require('shaka.media.ManifestParser');
  17. goog.require('shaka.media.MediaSourceEngine');
  18. goog.require('shaka.media.SegmentIterator');
  19. goog.require('shaka.media.SegmentReference');
  20. goog.require('shaka.media.SegmentPrefetch');
  21. goog.require('shaka.net.Backoff');
  22. goog.require('shaka.net.NetworkingEngine');
  23. goog.require('shaka.util.BufferUtils');
  24. goog.require('shaka.util.DelayedTick');
  25. goog.require('shaka.util.Destroyer');
  26. goog.require('shaka.util.Error');
  27. goog.require('shaka.util.FakeEvent');
  28. goog.require('shaka.util.IDestroyable');
  29. goog.require('shaka.util.Id3Utils');
  30. goog.require('shaka.util.LanguageUtils');
  31. goog.require('shaka.util.ManifestParserUtils');
  32. goog.require('shaka.util.MimeUtils');
  33. goog.require('shaka.util.Mp4BoxParsers');
  34. goog.require('shaka.util.Mp4Parser');
  35. goog.require('shaka.util.Networking');
  38. /**
  39.  * @summary Creates a Streaming Engine.
  40.  * The StreamingEngine is responsible for setting up the Manifest's Streams
  41.  * (i.e., for calling each Stream's createSegmentIndex() function), for
  42.  * downloading segments, for co-ordinating audio, video, and text buffering.
  43.  * The StreamingEngine provides an interface to switch between Streams, but it
  44.  * does not choose which Streams to switch to.
  45.  *
  46.  * The StreamingEngine does not need to be notified about changes to the
  47.  * Manifest's SegmentIndexes; however, it does need to be notified when new
  48.  * Variants are added to the Manifest.
  49.  *
  50.  * To start the StreamingEngine the owner must first call configure(), followed
  51.  * by one call to switchVariant(), one optional call to switchTextStream(), and
  52.  * finally a call to start().  After start() resolves, switch*() can be used
  53.  * freely.
  54.  *
  55.  * The owner must call seeked() each time the playhead moves to a new location
  56.  * within the presentation timeline; however, the owner may forego calling
  57.  * seeked() when the playhead moves outside the presentation timeline.
  58.  *
  59.  * @implements {shaka.util.IDestroyable}
  60.  */
  61. shaka.media.StreamingEngine = class {
  62.   /**
  63.    * @param {shaka.extern.Manifest} manifest
  64.    * @param {shaka.media.StreamingEngine.PlayerInterface} playerInterface
  65.    */
  66.   constructor(manifest, playerInterface) {
  67.     /** @private {?shaka.media.StreamingEngine.PlayerInterface} */
  68.     this.playerInterface_ = playerInterface;
  70.     /** @private {?shaka.extern.Manifest} */
  71.     this.manifest_ = manifest;
  73.     /** @private {?shaka.extern.StreamingConfiguration} */
  74.     this.config_ = null;
  76.     /** @private {number} */
  77.     this.bufferingGoalScale_ = 1;
  79.     /** @private {?shaka.extern.Variant} */
  80.     this.currentVariant_ = null;
  82.     /** @private {?shaka.extern.Stream} */
  83.     this.currentTextStream_ = null;
  85.     /** @private {number} */
  86.     this.textStreamSequenceId_ = 0;
  88.     /** @private {boolean} */
  89.     this.parsedPrftEventRaised_ = false;
  91.     /**
  92.      * Maps a content type, e.g., 'audio', 'video', or 'text', to a MediaState.
  93.      *
  94.      * @private {!Map.<shaka.util.ManifestParserUtils.ContentType,
  95.      *                 !shaka.media.StreamingEngine.MediaState_>}
  96.      */
  97.     this.mediaStates_ = new Map();
  99.     /**
  100.      * Set to true once the initial media states have been created.
  101.      *
  102.      * @private {boolean}
  103.      */
  104.     this.startupComplete_ = false;
  106.     /**
  107.      * Used for delay and backoff of failure callbacks, so that apps do not
  108.      * retry instantly.
  109.      *
  110.      * @private {shaka.net.Backoff}
  111.      */
  112.     this.failureCallbackBackoff_ = null;
  114.     /**
  115.      * Set to true on fatal error.  Interrupts fetchAndAppend_().
  116.      *
  117.      * @private {boolean}
  118.      */
  119.     this.fatalError_ = false;
  121.     /** @private {!shaka.util.Destroyer} */
  122.     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
  124.     /** @private {number} */
  125.     this.lastMediaSourceReset_ = Date.now() / 1000;
  127.     /**
  128.      * @private {!Map<shaka.extern.Stream, !shaka.media.SegmentPrefetch>}
  129.      */
  130.     this.audioPrefetchMap_ = new Map();
  132.     /** @private {!shaka.extern.SpatialVideoInfo} */
  133.     this.spatialVideoInfo_ = {
  134.       projection: null,
  135.       hfov: null,
  136.     };
  138.     /** @private {number} */
  139.     this.playRangeStart_ = 0;
  141.     /** @private {number} */
  142.     this.playRangeEnd_ = Infinity;
  143.   }
  145.   /** @override */
  146.   destroy() {
  147.     return this.destroyer_.destroy();
  148.   }
  150.   /**
  151.    * @return {!Promise}
  152.    * @private
  153.    */
  154.   async doDestroy_() {
  155.     const aborts = [];
  157.     for (const state of this.mediaStates_.values()) {
  158.       this.cancelUpdate_(state);
  159.       aborts.push(this.abortOperations_(state));
  160.       if (state.segmentPrefetch) {
  161.         state.segmentPrefetch.clearAll();
  162.         state.segmentPrefetch = null;
  163.       }
  164.     }
  165.     for (const prefetch of this.audioPrefetchMap_.values()) {
  166.       prefetch.clearAll();
  167.     }
  169.     await Promise.all(aborts);
  171.     this.mediaStates_.clear();
  172.     this.audioPrefetchMap_.clear();
  174.     this.playerInterface_ = null;
  175.     this.manifest_ = null;
  176.     this.config_ = null;
  177.   }
  179.   /**
  180.    * Called by the Player to provide an updated configuration any time it
  181.    * changes. Must be called at least once before start().
  182.    *
  183.    * @param {shaka.extern.StreamingConfiguration} config
  184.    */
  185.   configure(config) {
  186.     this.config_ = config;
  188.     // Create separate parameters for backoff during streaming failure.
  190.     /** @type {shaka.extern.RetryParameters} */
  191.     const failureRetryParams = {
  192.       // The term "attempts" includes the initial attempt, plus all retries.
  193.       // In order to see a delay, there would have to be at least 2 attempts.
  194.       maxAttempts: Math.max(config.retryParameters.maxAttempts, 2),
  195.       baseDelay: config.retryParameters.baseDelay,
  196.       backoffFactor: config.retryParameters.backoffFactor,
  197.       fuzzFactor: config.retryParameters.fuzzFactor,
  198.       timeout: 0,  // irrelevant
  199.       stallTimeout: 0, // irrelevant
  200.       connectionTimeout: 0, // irrelevant
  201.     };
  203.     // We don't want to ever run out of attempts.  The application should be
  204.     // allowed to retry streaming infinitely if it wishes.
  205.     const autoReset = true;
  206.     this.failureCallbackBackoff_ =
  207.         new shaka.net.Backoff(failureRetryParams, autoReset);
  209.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  211.     // disable audio segment prefetch if this is now set
  212.     if (config.disableAudioPrefetch) {
  213.       const state = this.mediaStates_.get(ContentType.AUDIO);
  214.       if (state && state.segmentPrefetch) {
  215.         state.segmentPrefetch.clearAll();
  216.         state.segmentPrefetch = null;
  217.       }
  219.       for (const stream of this.audioPrefetchMap_.keys()) {
  220.         const prefetch = this.audioPrefetchMap_.get(stream);
  221.         prefetch.clearAll();
  222.         this.audioPrefetchMap_.delete(stream);
  223.       }
  224.     }
  225.     // disable text segment prefetch if this is now set
  226.     if (config.disableTextPrefetch) {
  227.       const state = this.mediaStates_.get(ContentType.TEXT);
  228.       if (state && state.segmentPrefetch) {
  229.         state.segmentPrefetch.clearAll();
  230.         state.segmentPrefetch = null;
  231.       }
  232.     }
  234.     // disable video segment prefetch if this is now set
  235.     if (config.disableVideoPrefetch) {
  236.       const state = this.mediaStates_.get(ContentType.VIDEO);
  237.       if (state && state.segmentPrefetch) {
  238.         state.segmentPrefetch.clearAll();
  239.         state.segmentPrefetch = null;
  240.       }
  241.     }
  243.     // Allow configuring the segment prefetch in middle of the playback.
  244.     for (const type of this.mediaStates_.keys()) {
  245.       const state = this.mediaStates_.get(type);
  246.       if (state.segmentPrefetch) {
  247.         state.segmentPrefetch.resetLimit(config.segmentPrefetchLimit);
  248.         if (!(config.segmentPrefetchLimit > 0)) {
  249.           // ResetLimit is still needed in this case,
  250.           // to abort existing prefetch operations.
  251.           state.segmentPrefetch.clearAll();
  252.           state.segmentPrefetch = null;
  253.         }
  254.       } else if (config.segmentPrefetchLimit > 0) {
  255.         state.segmentPrefetch = this.createSegmentPrefetch_(state.stream);
  256.       }
  257.     }
  259.     if (!config.disableAudioPrefetch) {
  260.       this.updatePrefetchMapForAudio_();
  261.     }
  262.   }
  265.   /**
  266.    * Applies a playback range. This will only affect non-live content.
  267.    *
  268.    * @param {number} playRangeStart
  269.    * @param {number} playRangeEnd
  270.    */
  271.   applyPlayRange(playRangeStart, playRangeEnd) {
  272.     if (!this.manifest_.presentationTimeline.isLive()) {
  273.       this.playRangeStart_ = playRangeStart;
  274.       this.playRangeEnd_ = playRangeEnd;
  275.     }
  276.   }
  279.   /**
  280.    * Initialize and start streaming.
  281.    *
  282.    * By calling this method, StreamingEngine will start streaming the variant
  283.    * chosen by a prior call to switchVariant(), and optionally, the text stream
  284.    * chosen by a prior call to switchTextStream().  Once the Promise resolves,
  285.    * switch*() may be called freely.
  286.    *
  287.    * @param {!Map.<number, shaka.media.SegmentPrefetch>=} segmentPrefetchById
  288.    *   If provided, segments prefetched for these streams will be used as needed
  289.    *   during playback.
  290.    * @return {!Promise}
  291.    */
  292.   async start(segmentPrefetchById) {
  293.     goog.asserts.assert(this.config_,
  294.         'StreamingEngine configure() must be called before init()!');
  296.     // Setup the initial set of Streams and then begin each update cycle.
  297.     await this.initStreams_(segmentPrefetchById || (new Map()));
  298.     this.destroyer_.ensureNotDestroyed();
  300.     shaka.log.debug('init: completed initial Stream setup');
  301.     this.startupComplete_ = true;
  302.   }
  304.   /**
  305.    * Get the current variant we are streaming.  Returns null if nothing is
  306.    * streaming.
  307.    * @return {?shaka.extern.Variant}
  308.    */
  309.   getCurrentVariant() {
  310.     return this.currentVariant_;
  311.   }
  313.   /**
  314.    * Get the text stream we are streaming.  Returns null if there is no text
  315.    * streaming.
  316.    * @return {?shaka.extern.Stream}
  317.    */
  318.   getCurrentTextStream() {
  319.     return this.currentTextStream_;
  320.   }
  322.   /**
  323.    * Start streaming text, creating a new media state.
  324.    *
  325.    * @param {shaka.extern.Stream} stream
  326.    * @return {!Promise}
  327.    * @private
  328.    */
  329.   async loadNewTextStream_(stream) {
  330.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  331.     goog.asserts.assert(!this.mediaStates_.has(ContentType.TEXT),
  332.         'Should not call loadNewTextStream_ while streaming text!');
  333.     this.textStreamSequenceId_++;
  334.     const currentSequenceId = this.textStreamSequenceId_;
  336.     try {
  337.       // Clear MediaSource's buffered text, so that the new text stream will
  338.       // properly replace the old buffered text.
  339.       // TODO: Should this happen in unloadTextStream() instead?
  340.       await this.playerInterface_.mediaSourceEngine.clear(ContentType.TEXT);
  341.     } catch (error) {
  342.       if (this.playerInterface_) {
  343.         this.playerInterface_.onError(error);
  344.       }
  345.     }
  347.     const mimeType = shaka.util.MimeUtils.getFullType(
  348.         stream.mimeType, stream.codecs);
  349.     this.playerInterface_.mediaSourceEngine.reinitText(
  350.         mimeType, this.manifest_.sequenceMode, stream.external);
  352.     const textDisplayer =
  353.         this.playerInterface_.mediaSourceEngine.getTextDisplayer();
  354.     const streamText =
  355.         textDisplayer.isTextVisible() || this.config_.alwaysStreamText;
  357.     if (streamText && (this.textStreamSequenceId_ == currentSequenceId)) {
  358.       const state = this.createMediaState_(stream);
  359.       this.mediaStates_.set(ContentType.TEXT, state);
  360.       this.scheduleUpdate_(state, 0);
  361.     }
  362.   }
  365.   /**
  366.    * Stop fetching text stream when the user chooses to hide the captions.
  367.    */
  368.   unloadTextStream() {
  369.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  371.     const state = this.mediaStates_.get(ContentType.TEXT);
  372.     if (state) {
  373.       this.cancelUpdate_(state);
  374.       this.abortOperations_(state).catch(() => {});
  375.       this.mediaStates_.delete(ContentType.TEXT);
  376.     }
  377.     this.currentTextStream_ = null;
  378.   }
  380.   /**
  381.    * Set trick play on or off.
  382.    * If trick play is on, related trick play streams will be used when possible.
  383.    * @param {boolean} on
  384.    */
  385.   setTrickPlay(on) {
  386.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  388.     this.updateSegmentIteratorReverse_();
  390.     const mediaState = this.mediaStates_.get(ContentType.VIDEO);
  391.     if (!mediaState) {
  392.       return;
  393.     }
  395.     const stream = mediaState.stream;
  396.     if (!stream) {
  397.       return;
  398.     }
  400.     shaka.log.debug('setTrickPlay', on);
  401.     if (on) {
  402.       const trickModeVideo = stream.trickModeVideo;
  403.       if (!trickModeVideo) {
  404.         return;  // Can't engage trick play.
  405.       }
  407.       const normalVideo = mediaState.restoreStreamAfterTrickPlay;
  408.       if (normalVideo) {
  409.         return;  // Already in trick play.
  410.       }
  412.       shaka.log.debug('Engaging trick mode stream', trickModeVideo);
  413.       this.switchInternal_(trickModeVideo, /* clearBuffer= */ false,
  414.           /* safeMargin= */ 0, /* force= */ false);
  416.       mediaState.restoreStreamAfterTrickPlay = stream;
  417.     } else {
  418.       const normalVideo = mediaState.restoreStreamAfterTrickPlay;
  419.       if (!normalVideo) {
  420.         return;
  421.       }
  423.       shaka.log.debug('Restoring non-trick-mode stream', normalVideo);
  424.       mediaState.restoreStreamAfterTrickPlay = null;
  425.       this.switchInternal_(normalVideo, /* clearBuffer= */ true,
  426.           /* safeMargin= */ 0, /* force= */ false);
  427.     }
  428.   }
  431.   /**
  432.    * @param {shaka.extern.Variant} variant
  433.    * @param {boolean=} clearBuffer
  434.    * @param {number=} safeMargin
  435.    * @param {boolean=} force
  436.    *   If true, reload the variant even if it did not change.
  437.    * @param {boolean=} adaptation
  438.    *   If true, update the media state to indicate MediaSourceEngine should
  439.    *   reset the timestamp offset to ensure the new track segments are correctly
  440.    *   placed on the timeline.
  441.    */
  442.   switchVariant(
  443.       variant, clearBuffer = false, safeMargin = 0, force = false,
  444.       adaptation = false) {
  445.     this.currentVariant_ = variant;
  447.     if (!this.startupComplete_) {
  448.       // The selected variant will be used in start().
  449.       return;
  450.     }
  452.     if (variant.video) {
  453.       this.switchInternal_(
  454.           variant.video, /* clearBuffer= */ clearBuffer,
  455.           /* safeMargin= */ safeMargin, /* force= */ force,
  456.           /* adaptation= */ adaptation);
  457.     }
  458.     if (variant.audio) {
  459.       this.switchInternal_(
  460.           variant.audio, /* clearBuffer= */ clearBuffer,
  461.           /* safeMargin= */ safeMargin, /* force= */ force,
  462.           /* adaptation= */ adaptation);
  463.     }
  464.   }
  467.   /**
  468.    * @param {shaka.extern.Stream} textStream
  469.    */
  470.   async switchTextStream(textStream) {
  471.     this.currentTextStream_ = textStream;
  473.     if (!this.startupComplete_) {
  474.       // The selected text stream will be used in start().
  475.       return;
  476.     }
  478.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  479.     goog.asserts.assert(textStream && textStream.type == ContentType.TEXT,
  480.         'Wrong stream type passed to switchTextStream!');
  482.     // In HLS it is possible that the mimetype changes when the media
  483.     // playlist is downloaded, so it is necessary to have the updated data
  484.     // here.
  485.     if (!textStream.segmentIndex) {
  486.       await textStream.createSegmentIndex();
  487.     }
  489.     this.switchInternal_(
  490.         textStream, /* clearBuffer= */ true,
  491.         /* safeMargin= */ 0, /* force= */ false);
  492.   }
  495.   /** Reload the current text stream. */
  496.   reloadTextStream() {
  497.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  498.     const mediaState = this.mediaStates_.get(ContentType.TEXT);
  499.     if (mediaState) { // Don't reload if there's no text to begin with.
  500.       this.switchInternal_(
  501.           mediaState.stream, /* clearBuffer= */ true,
  502.           /* safeMargin= */ 0, /* force= */ true);
  503.     }
  504.   }
  507.   /**
  508.    * Switches to the given Stream. |stream| may be from any Variant.
  509.    *
  510.    * @param {shaka.extern.Stream} stream
  511.    * @param {boolean} clearBuffer
  512.    * @param {number} safeMargin
  513.    * @param {boolean} force
  514.    *   If true, reload the text stream even if it did not change.
  515.    * @param {boolean=} adaptation
  516.    *   If true, update the media state to indicate MediaSourceEngine should
  517.    *   reset the timestamp offset to ensure the new track segments are correctly
  518.    *   placed on the timeline.
  519.    * @private
  520.    */
  521.   switchInternal_(stream, clearBuffer, safeMargin, force, adaptation) {
  522.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  523.     const type = /** @type {!ContentType} */(stream.type);
  524.     const mediaState = this.mediaStates_.get(type);
  526.     if (!mediaState && stream.type == ContentType.TEXT) {
  527.       this.loadNewTextStream_(stream);
  528.       return;
  529.     }
  531.     goog.asserts.assert(mediaState, 'switch: expected mediaState to exist');
  532.     if (!mediaState) {
  533.       return;
  534.     }
  536.     if (mediaState.restoreStreamAfterTrickPlay) {
  537.       shaka.log.debug('switch during trick play mode', stream);
  539.       // Already in trick play mode, so stick with trick mode tracks if
  540.       // possible.
  541.       if (stream.trickModeVideo) {
  542.         // Use the trick mode stream, but revert to the new selection later.
  543.         mediaState.restoreStreamAfterTrickPlay = stream;
  544.         stream = stream.trickModeVideo;
  545.         shaka.log.debug('switch found trick play stream', stream);
  546.       } else {
  547.         // There is no special trick mode video for this stream!
  548.         mediaState.restoreStreamAfterTrickPlay = null;
  549.         shaka.log.debug('switch found no special trick play stream');
  550.       }
  551.     }
  553.     if (mediaState.stream == stream && !force) {
  554.       const streamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
  555.       shaka.log.debug('switch: Stream ' + streamTag + ' already active');
  556.       return;
  557.     }
  559.     if (this.audioPrefetchMap_.has(stream)) {
  560.       mediaState.segmentPrefetch = this.audioPrefetchMap_.get(stream);
  561.     } else if (mediaState.segmentPrefetch) {
  562.       mediaState.segmentPrefetch.switchStream(stream);
  563.     }
  565.     if (stream.type == ContentType.TEXT) {
  566.       // Mime types are allowed to change for text streams.
  567.       // Reinitialize the text parser, but only if we are going to fetch the
  568.       // init segment again.
  569.       const fullMimeType = shaka.util.MimeUtils.getFullType(
  570.           stream.mimeType, stream.codecs);
  571.       this.playerInterface_.mediaSourceEngine.reinitText(
  572.           fullMimeType, this.manifest_.sequenceMode, stream.external);
  573.     }
  575.     // Releases the segmentIndex of the old stream.
  576.     // Do not close segment indexes we are prefetching.
  577.     if (!this.audioPrefetchMap_.has(mediaState.stream)) {
  578.       if (mediaState.stream.closeSegmentIndex) {
  579.         mediaState.stream.closeSegmentIndex();
  580.       }
  581.     }
  583.     mediaState.stream = stream;
  584.     mediaState.segmentIterator = null;
  585.     mediaState.adaptation = !!adaptation;
  587.     const streamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
  588.     shaka.log.debug('switch: switching to Stream ' + streamTag);
  590.     if (clearBuffer) {
  591.       if (mediaState.clearingBuffer) {
  592.         // We are already going to clear the buffer, but make sure it is also
  593.         // flushed.
  594.         mediaState.waitingToFlushBuffer = true;
  595.       } else if (mediaState.performingUpdate) {
  596.         // We are performing an update, so we have to wait until it's finished.
  597.         // onUpdate_() will call clearBuffer_() when the update has finished.
  598.         // We need to save the safe margin because its value will be needed when
  599.         // clearing the buffer after the update.
  600.         mediaState.waitingToClearBuffer = true;
  601.         mediaState.clearBufferSafeMargin = safeMargin;
  602.         mediaState.waitingToFlushBuffer = true;
  603.       } else {
  604.         // Cancel the update timer, if any.
  605.         this.cancelUpdate_(mediaState);
  606.         // Clear right away.
  607.         this.clearBuffer_(mediaState, /* flush= */ true, safeMargin)
  608.             .catch((error) => {
  609.               if (this.playerInterface_) {
  610.                 goog.asserts.assert(error instanceof shaka.util.Error,
  611.                     'Wrong error type!');
  612.                 this.playerInterface_.onError(error);
  613.               }
  614.             });
  615.       }
  616.     } else {
  617.       if (!mediaState.performingUpdate && !mediaState.updateTimer) {
  618.         this.scheduleUpdate_(mediaState, 0);
  619.       }
  620.     }
  622.     this.makeAbortDecision_(mediaState).catch((error) => {
  623.       if (this.playerInterface_) {
  624.         goog.asserts.assert(error instanceof shaka.util.Error,
  625.             'Wrong error type!');
  626.         this.playerInterface_.onError(error);
  627.       }
  628.     });
  629.   }
  632.   /**
  633.    * Decide if it makes sense to abort the current operation, and abort it if
  634.    * so.
  635.    *
  636.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  637.    * @private
  638.    */
  639.   async makeAbortDecision_(mediaState) {
  640.     // If the operation is completed, it will be set to null, and there's no
  641.     // need to abort the request.
  642.     if (!mediaState.operation) {
  643.       return;
  644.     }
  646.     const originalStream = mediaState.stream;
  647.     const originalOperation = mediaState.operation;
  649.     if (!originalStream.segmentIndex) {
  650.       // Create the new segment index so the time taken is accounted for when
  651.       // deciding whether to abort.
  652.       await originalStream.createSegmentIndex();
  653.     }
  655.     if (mediaState.operation != originalOperation) {
  656.       // The original operation completed while we were getting a segment index,
  657.       // so there's nothing to do now.
  658.       return;
  659.     }
  661.     if (mediaState.stream != originalStream) {
  662.       // The stream changed again while we were getting a segment index.  We
  663.       // can't carry out this check, since another one might be in progress by
  664.       // now.
  665.       return;
  666.     }
  668.     goog.asserts.assert(mediaState.stream.segmentIndex,
  669.         'Segment index should exist by now!');
  671.     if (this.shouldAbortCurrentRequest_(mediaState)) {
  672.       shaka.log.info('Aborting current segment request.');
  673.       mediaState.operation.abort();
  674.     }
  675.   }
  677.   /**
  678.    * Returns whether we should abort the current request.
  679.    *
  680.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  681.    * @return {boolean}
  682.    * @private
  683.    */
  684.   shouldAbortCurrentRequest_(mediaState) {
  685.     goog.asserts.assert(mediaState.operation,
  686.         'Abort logic requires an ongoing operation!');
  687.     goog.asserts.assert(mediaState.stream && mediaState.stream.segmentIndex,
  688.         'Abort logic requires a segment index');
  690.     const presentationTime = this.playerInterface_.getPresentationTime();
  691.     const bufferEnd =
  692.         this.playerInterface_.mediaSourceEngine.bufferEnd(mediaState.type);
  694.     // The next segment to append from the current stream.  This doesn't
  695.     // account for a pending network request and will likely be different from
  696.     // that since we just switched.
  697.     const timeNeeded = this.getTimeNeeded_(mediaState, presentationTime);
  698.     const index = mediaState.stream.segmentIndex.find(timeNeeded);
  699.     const newSegment =
  700.         index == null ? null : mediaState.stream.segmentIndex.get(index);
  702.     let newSegmentSize = newSegment ? newSegment.getSize() : null;
  703.     if (newSegment && !newSegmentSize) {
  704.       // compute approximate segment size using stream bandwidth
  705.       const duration = newSegment.getEndTime() - newSegment.getStartTime();
  706.       const bandwidth = mediaState.stream.bandwidth || 0;
  707.       // bandwidth is in bits per second, and the size is in bytes
  708.       newSegmentSize = duration * bandwidth / 8;
  709.     }
  711.     if (!newSegmentSize) {
  712.       return false;
  713.     }
  715.     // When switching, we'll need to download the init segment.
  716.     const init = newSegment.initSegmentReference;
  717.     if (init) {
  718.       newSegmentSize += init.getSize() || 0;
  719.     }
  721.     const bandwidthEstimate = this.playerInterface_.getBandwidthEstimate();
  723.     // The estimate is in bits per second, and the size is in bytes.  The time
  724.     // remaining is in seconds after this calculation.
  725.     const timeToFetchNewSegment = (newSegmentSize * 8) / bandwidthEstimate;
  727.     // If the new segment can be finished in time without risking a buffer
  728.     // underflow, we should abort the old one and switch.
  729.     const bufferedAhead = (bufferEnd || 0) - presentationTime;
  730.     const safetyBuffer = Math.max(
  731.         this.manifest_.minBufferTime || 0,
  732.         this.config_.rebufferingGoal);
  733.     const safeBufferedAhead = bufferedAhead - safetyBuffer;
  734.     if (timeToFetchNewSegment < safeBufferedAhead) {
  735.       return true;
  736.     }
  738.     // If the thing we want to switch to will be done more quickly than what
  739.     // we've got in progress, we should abort the old one and switch.
  740.     const bytesRemaining = mediaState.operation.getBytesRemaining();
  741.     if (bytesRemaining > newSegmentSize) {
  742.       return true;
  743.     }
  745.     // Otherwise, complete the operation in progress.
  746.     return false;
  747.   }
  750.   /**
  751.    * Notifies the StreamingEngine that the playhead has moved to a valid time
  752.    * within the presentation timeline.
  753.    */
  754.   seeked() {
  755.     if (!this.playerInterface_) {
  756.       // Already destroyed.
  757.       return;
  758.     }
  760.     const presentationTime = this.playerInterface_.getPresentationTime();
  761.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  762.     const newTimeIsBuffered = (type) => {
  763.       return this.playerInterface_.mediaSourceEngine.isBuffered(
  764.           type, presentationTime);
  765.     };
  767.     let streamCleared = false;
  768.     for (const type of this.mediaStates_.keys()) {
  769.       const mediaState = this.mediaStates_.get(type);
  770.       const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  772.       let segment = null;
  773.       if (mediaState.segmentIterator) {
  774.         segment = mediaState.segmentIterator.current();
  775.       }
  776.       if (mediaState.segmentPrefetch) {
  777.         mediaState.segmentPrefetch.resetPosition();
  778.       }
  779.       if (mediaState.type === ContentType.AUDIO) {
  780.         for (const prefetch of this.audioPrefetchMap_.values()) {
  781.           prefetch.resetPosition();
  782.         }
  783.       }
  784.       // Only reset the iterator if we seek outside the current segment.
  785.       if (!segment || segment.startTime > presentationTime ||
  786.           segment.endTime < presentationTime) {
  787.         mediaState.segmentIterator = null;
  788.       }
  790.       if (!newTimeIsBuffered(type)) {
  791.         const bufferEnd =
  792.             this.playerInterface_.mediaSourceEngine.bufferEnd(type);
  793.         const somethingBuffered = bufferEnd != null;
  795.         // Don't clear the buffer unless something is buffered.  This extra
  796.         // check prevents extra, useless calls to clear the buffer.
  797.         if (somethingBuffered || mediaState.performingUpdate) {
  798.           this.forceClearBuffer_(mediaState);
  799.           streamCleared = true;
  800.         }
  802.         // If there is an operation in progress, stop it now.
  803.         if (mediaState.operation) {
  804.           mediaState.operation.abort();
  805.           shaka.log.debug(logPrefix, 'Aborting operation due to seek');
  806.           mediaState.operation = null;
  807.         }
  809.         // The pts has shifted from the seek, invalidating captions currently
  810.         // in the text buffer. Thus, clear and reset the caption parser.
  811.         if (type === ContentType.TEXT) {
  812.           this.playerInterface_.mediaSourceEngine.resetCaptionParser();
  813.         }
  815.         // Mark the media state as having seeked, so that the new buffers know
  816.         // that they will need to be at a new position (for sequence mode).
  817.         mediaState.seeked = true;
  818.       }
  819.     }
  821.     if (!streamCleared) {
  822.       shaka.log.debug(
  823.           '(all): seeked: buffered seek: presentationTime=' + presentationTime);
  824.     }
  825.   }
  828.   /**
  829.    * Clear the buffer for a given stream.  Unlike clearBuffer_, this will handle
  830.    * cases where a MediaState is performing an update.  After this runs, the
  831.    * MediaState will have a pending update.
  832.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  833.    * @private
  834.    */
  835.   forceClearBuffer_(mediaState) {
  836.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  838.     if (mediaState.clearingBuffer) {
  839.       // We're already clearing the buffer, so we don't need to clear the
  840.       // buffer again.
  841.       shaka.log.debug(logPrefix, 'clear: already clearing the buffer');
  842.       return;
  843.     }
  845.     if (mediaState.waitingToClearBuffer) {
  846.       // May not be performing an update, but an update will still happen.
  847.       // See: https://github.com/shaka-project/shaka-player/issues/334
  848.       shaka.log.debug(logPrefix, 'clear: already waiting');
  849.       return;
  850.     }
  852.     if (mediaState.performingUpdate) {
  853.       // We are performing an update, so we have to wait until it's finished.
  854.       // onUpdate_() will call clearBuffer_() when the update has finished.
  855.       shaka.log.debug(logPrefix, 'clear: currently updating');
  856.       mediaState.waitingToClearBuffer = true;
  857.       // We can set the offset to zero to remember that this was a call to
  858.       // clearAllBuffers.
  859.       mediaState.clearBufferSafeMargin = 0;
  860.       return;
  861.     }
  863.     const type = mediaState.type;
  864.     if (this.playerInterface_.mediaSourceEngine.bufferStart(type) == null) {
  865.       // Nothing buffered.
  866.       shaka.log.debug(logPrefix, 'clear: nothing buffered');
  867.       if (mediaState.updateTimer == null) {
  868.         // Note: an update cycle stops when we buffer to the end of the
  869.         // presentation, or when we raise an error.
  870.         this.scheduleUpdate_(mediaState, 0);
  871.       }
  872.       return;
  873.     }
  875.     // An update may be scheduled, but we can just cancel it and clear the
  876.     // buffer right away. Note: clearBuffer_() will schedule the next update.
  877.     shaka.log.debug(logPrefix, 'clear: handling right now');
  878.     this.cancelUpdate_(mediaState);
  879.     this.clearBuffer_(mediaState, /* flush= */ false, 0).catch((error) => {
  880.       if (this.playerInterface_) {
  881.         goog.asserts.assert(error instanceof shaka.util.Error,
  882.             'Wrong error type!');
  883.         this.playerInterface_.onError(error);
  884.       }
  885.     });
  886.   }
  889.   /**
  890.    * Initializes the initial streams and media states.  This will schedule
  891.    * updates for the given types.
  892.    *
  893.    * @param {!Map.<number, shaka.media.SegmentPrefetch>} segmentPrefetchById
  894.    * @return {!Promise}
  895.    * @private
  896.    */
  897.   async initStreams_(segmentPrefetchById) {
  898.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  900.     goog.asserts.assert(this.config_,
  901.         'StreamingEngine configure() must be called before init()!');
  903.     if (!this.currentVariant_) {
  904.       shaka.log.error('init: no Streams chosen');
  905.       throw new shaka.util.Error(
  906.           shaka.util.Error.Severity.CRITICAL,
  907.           shaka.util.Error.Category.STREAMING,
  908.           shaka.util.Error.Code.STREAMING_ENGINE_STARTUP_INVALID_STATE);
  909.     }
  911.     /**
  912.      * @type {!Map.<shaka.util.ManifestParserUtils.ContentType,
  913.      *              shaka.extern.Stream>}
  914.      */
  915.     const streamsByType = new Map();
  916.     /** @type {!Set.<shaka.extern.Stream>} */
  917.     const streams = new Set();
  919.     if (this.currentVariant_.audio) {
  920.       streamsByType.set(ContentType.AUDIO, this.currentVariant_.audio);
  921.       streams.add(this.currentVariant_.audio);
  922.     }
  924.     if (this.currentVariant_.video) {
  925.       streamsByType.set(ContentType.VIDEO, this.currentVariant_.video);
  926.       streams.add(this.currentVariant_.video);
  927.     }
  929.     if (this.currentTextStream_) {
  930.       streamsByType.set(ContentType.TEXT, this.currentTextStream_);
  931.       streams.add(this.currentTextStream_);
  932.     }
  934.     // Init MediaSourceEngine.
  935.     const mediaSourceEngine = this.playerInterface_.mediaSourceEngine;
  937.     await mediaSourceEngine.init(streamsByType,
  938.         this.manifest_.sequenceMode,
  939.         this.manifest_.type,
  940.         this.manifest_.ignoreManifestTimestampsInSegmentsMode,
  941.     );
  942.     this.destroyer_.ensureNotDestroyed();
  944.     this.updateDuration();
  946.     for (const type of streamsByType.keys()) {
  947.       const stream = streamsByType.get(type);
  948.       if (!this.mediaStates_.has(type)) {
  949.         const mediaState = this.createMediaState_(stream);
  950.         if (segmentPrefetchById.has(stream.id)) {
  951.           const segmentPrefetch = segmentPrefetchById.get(stream.id);
  952.           segmentPrefetch.replaceFetchDispatcher(
  953.               (reference, stream, streamDataCallback) => {
  954.                 return this.dispatchFetch_(
  955.                     reference, stream, streamDataCallback);
  956.               });
  957.           mediaState.segmentPrefetch = segmentPrefetch;
  958.         }
  959.         this.mediaStates_.set(type, mediaState);
  960.         this.scheduleUpdate_(mediaState, 0);
  961.       }
  962.     }
  963.   }
  966.   /**
  967.    * Creates a media state.
  968.    *
  969.    * @param {shaka.extern.Stream} stream
  970.    * @return {shaka.media.StreamingEngine.MediaState_}
  971.    * @private
  972.    */
  973.   createMediaState_(stream) {
  974.     return /** @type {shaka.media.StreamingEngine.MediaState_} */ ({
  975.       stream,
  976.       type: stream.type,
  977.       segmentIterator: null,
  978.       segmentPrefetch: this.createSegmentPrefetch_(stream),
  979.       lastSegmentReference: null,
  980.       lastInitSegmentReference: null,
  981.       lastTimestampOffset: null,
  982.       lastAppendWindowStart: null,
  983.       lastAppendWindowEnd: null,
  984.       restoreStreamAfterTrickPlay: null,
  985.       endOfStream: false,
  986.       performingUpdate: false,
  987.       updateTimer: null,
  988.       waitingToClearBuffer: false,
  989.       clearBufferSafeMargin: 0,
  990.       waitingToFlushBuffer: false,
  991.       clearingBuffer: false,
  992.       // The playhead might be seeking on startup, if a start time is set, so
  993.       // start "seeked" as true.
  994.       seeked: true,
  995.       recovering: false,
  996.       hasError: false,
  997.       operation: null,
  998.     });
  999.   }
  1001.   /**
  1002.    * Creates a media state.
  1003.    *
  1004.    * @param {shaka.extern.Stream} stream
  1005.    * @return {shaka.media.SegmentPrefetch | null}
  1006.    * @private
  1007.    */
  1008.   createSegmentPrefetch_(stream) {
  1009.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1010.     if (stream.type === ContentType.VIDEO &&
  1011.         this.config_.disableVideoPrefetch) {
  1012.       return null;
  1013.     }
  1014.     if (stream.type === ContentType.AUDIO &&
  1015.         this.config_.disableAudioPrefetch) {
  1016.       return null;
  1017.     }
  1018.     const MimeUtils = shaka.util.MimeUtils;
  1019.     const CEA608_MIME = MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE;
  1020.     const CEA708_MIME = MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE;
  1021.     if (stream.type === ContentType.TEXT &&
  1022.         (stream.mimeType == CEA608_MIME || stream.mimeType == CEA708_MIME)) {
  1023.       return null;
  1024.     }
  1025.     if (stream.type === ContentType.TEXT &&
  1026.         this.config_.disableTextPrefetch) {
  1027.       return null;
  1028.     }
  1029.     if (this.audioPrefetchMap_.has(stream)) {
  1030.       return this.audioPrefetchMap_.get(stream);
  1031.     }
  1032.     const type = /** @type {!shaka.util.ManifestParserUtils.ContentType} */
  1033.         (stream.type);
  1034.     const mediaState = this.mediaStates_.get(type);
  1035.     const currentSegmentPrefetch = mediaState && mediaState.segmentPrefetch;
  1036.     if (currentSegmentPrefetch &&
  1037.       stream === currentSegmentPrefetch.getStream()) {
  1038.       return currentSegmentPrefetch;
  1039.     }
  1040.     if (this.config_.segmentPrefetchLimit > 0) {
  1041.       const reverse = this.playerInterface_.getPlaybackRate() < 0;
  1042.       return new shaka.media.SegmentPrefetch(
  1043.           this.config_.segmentPrefetchLimit,
  1044.           stream,
  1045.           (reference, stream, streamDataCallback) => {
  1046.             return this.dispatchFetch_(reference, stream, streamDataCallback);
  1047.           },
  1048.           reverse);
  1049.     }
  1050.     return null;
  1051.   }
  1053.   /**
  1054.    * Populates the prefetch map depending on the configuration
  1055.    * @private
  1056.    */
  1057.   updatePrefetchMapForAudio_() {
  1058.     const prefetchLimit = this.config_.segmentPrefetchLimit;
  1059.     const prefetchLanguages = this.config_.prefetchAudioLanguages;
  1060.     const LanguageUtils = shaka.util.LanguageUtils;
  1062.     for (const variant of this.manifest_.variants) {
  1063.       if (!variant.audio) {
  1064.         continue;
  1065.       }
  1067.       if (this.audioPrefetchMap_.has(variant.audio)) {
  1068.         // if we already have a segment prefetch,
  1069.         // update it's prefetch limit and if the new limit isn't positive,
  1070.         // remove the segment prefetch from our prefetch map.
  1071.         const prefetch = this.audioPrefetchMap_.get(variant.audio);
  1072.         prefetch.resetLimit(prefetchLimit);
  1073.         if (!(prefetchLimit > 0) ||
  1074.             !prefetchLanguages.some(
  1075.                 (lang) => LanguageUtils.areLanguageCompatible(
  1076.                     variant.audio.language, lang))
  1077.         ) {
  1078.           const type = /** @type {!shaka.util.ManifestParserUtils.ContentType}*/
  1079.             (variant.audio.type);
  1080.           const mediaState = this.mediaStates_.get(type);
  1081.           const currentSegmentPrefetch = mediaState &&
  1082.               mediaState.segmentPrefetch;
  1083.           // if this prefetch isn't the current one, we want to clear it
  1084.           if (prefetch !== currentSegmentPrefetch) {
  1085.             prefetch.clearAll();
  1086.           }
  1087.           this.audioPrefetchMap_.delete(variant.audio);
  1088.         }
  1089.         continue;
  1090.       }
  1092.       // don't try to create a new segment prefetch if the limit isn't positive.
  1093.       if (prefetchLimit <= 0) {
  1094.         continue;
  1095.       }
  1097.       // only create a segment prefetch if its language is configured
  1098.       // to be prefetched
  1099.       if (!prefetchLanguages.some(
  1100.           (lang) => LanguageUtils.areLanguageCompatible(
  1101.               variant.audio.language, lang))) {
  1102.         continue;
  1103.       }
  1105.       // use the helper to create a segment prefetch to ensure that existing
  1106.       // objects are reused.
  1107.       const segmentPrefetch = this.createSegmentPrefetch_(variant.audio);
  1109.       // if a segment prefetch wasn't created, skip the rest
  1110.       if (!segmentPrefetch) {
  1111.         continue;
  1112.       }
  1114.       if (!variant.audio.segmentIndex) {
  1115.         variant.audio.createSegmentIndex();
  1116.       }
  1118.       this.audioPrefetchMap_.set(variant.audio, segmentPrefetch);
  1119.     }
  1120.   }
  1122.   /**
  1123.    * Sets the MediaSource's duration.
  1124.    */
  1125.   updateDuration() {
  1126.     const duration = this.manifest_.presentationTimeline.getDuration();
  1127.     if (duration < Infinity) {
  1128.       this.playerInterface_.mediaSourceEngine.setDuration(duration);
  1129.     } else {
  1130.       // To set the media source live duration as Infinity
  1131.       // If infiniteLiveStreamDuration as true
  1132.       const duration =
  1133.       this.config_.infiniteLiveStreamDuration ? Infinity : Math.pow(2, 32);
  1134.       // Not all platforms support infinite durations, so set a finite duration
  1135.       // so we can append segments and so the user agent can seek.
  1136.       this.playerInterface_.mediaSourceEngine.setDuration(duration);
  1137.     }
  1138.   }
  1141.   /**
  1142.    * Called when |mediaState|'s update timer has expired.
  1143.    *
  1144.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  1145.    * @suppress {suspiciousCode} The compiler assumes that updateTimer can't
  1146.    *   change during the await, and so complains about the null check.
  1147.    * @private
  1148.    */
  1149.   async onUpdate_(mediaState) {
  1150.     this.destroyer_.ensureNotDestroyed();
  1152.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1154.     // Sanity check.
  1155.     goog.asserts.assert(
  1156.         !mediaState.performingUpdate && (mediaState.updateTimer != null),
  1157.         logPrefix + ' unexpected call to onUpdate_()');
  1158.     if (mediaState.performingUpdate || (mediaState.updateTimer == null)) {
  1159.       return;
  1160.     }
  1162.     goog.asserts.assert(
  1163.         !mediaState.clearingBuffer, logPrefix +
  1164.         ' onUpdate_() should not be called when clearing the buffer');
  1165.     if (mediaState.clearingBuffer) {
  1166.       return;
  1167.     }
  1169.     mediaState.updateTimer = null;
  1171.     // Handle pending buffer clears.
  1172.     if (mediaState.waitingToClearBuffer) {
  1173.       // Note: clearBuffer_() will schedule the next update.
  1174.       shaka.log.debug(logPrefix, 'skipping update and clearing the buffer');
  1175.       await this.clearBuffer_(
  1176.           mediaState, mediaState.waitingToFlushBuffer,
  1177.           mediaState.clearBufferSafeMargin);
  1178.       return;
  1179.     }
  1181.     // Make sure the segment index exists. If not, create the segment index.
  1182.     if (!mediaState.stream.segmentIndex) {
  1183.       const thisStream = mediaState.stream;
  1185.       try {
  1186.         await mediaState.stream.createSegmentIndex();
  1187.       } catch (error) {
  1188.         await this.handleStreamingError_(mediaState, error);
  1189.         return;
  1190.       }
  1192.       if (thisStream != mediaState.stream) {
  1193.         // We switched streams while in the middle of this async call to
  1194.         // createSegmentIndex.  Abandon this update and schedule a new one if
  1195.         // there's not already one pending.
  1196.         // Releases the segmentIndex of the old stream.
  1197.         if (thisStream.closeSegmentIndex) {
  1198.           goog.asserts.assert(!mediaState.stream.segmentIndex,
  1199.               'mediastate.stream should not have segmentIndex yet.');
  1200.           thisStream.closeSegmentIndex();
  1201.         }
  1202.         if (!mediaState.performingUpdate && !mediaState.updateTimer) {
  1203.           this.scheduleUpdate_(mediaState, 0);
  1204.         }
  1205.         return;
  1206.       }
  1207.     }
  1209.     // Update the MediaState.
  1210.     try {
  1211.       const delay = this.update_(mediaState);
  1212.       if (delay != null) {
  1213.         this.scheduleUpdate_(mediaState, delay);
  1214.         mediaState.hasError = false;
  1215.       }
  1216.     } catch (error) {
  1217.       await this.handleStreamingError_(mediaState, error);
  1218.       return;
  1219.     }
  1221.     const mediaStates = Array.from(this.mediaStates_.values());
  1223.     // Check if we've buffered to the end of the presentation.  We delay adding
  1224.     // the audio and video media states, so it is possible for the text stream
  1225.     // to be the only state and buffer to the end.  So we need to wait until we
  1226.     // have completed startup to determine if we have reached the end.
  1227.     if (this.startupComplete_ &&
  1228.         mediaStates.every((ms) => ms.endOfStream)) {
  1229.       shaka.log.v1(logPrefix, 'calling endOfStream()...');
  1230.       await this.playerInterface_.mediaSourceEngine.endOfStream();
  1231.       this.destroyer_.ensureNotDestroyed();
  1233.       // If the media segments don't reach the end, then we need to update the
  1234.       // timeline duration to match the final media duration to avoid
  1235.       // buffering forever at the end.
  1236.       // We should only do this if the duration needs to shrink.
  1237.       // Growing it by less than 1ms can actually cause buffering on
  1238.       // replay, as in https://github.com/shaka-project/shaka-player/issues/979
  1239.       // On some platforms, this can spuriously be 0, so ignore this case.
  1240.       // https://github.com/shaka-project/shaka-player/issues/1967,
  1241.       const duration = this.playerInterface_.mediaSourceEngine.getDuration();
  1242.       if (duration != 0 &&
  1243.           duration < this.manifest_.presentationTimeline.getDuration()) {
  1244.         this.manifest_.presentationTimeline.setDuration(duration);
  1245.       }
  1246.     }
  1247.   }
  1250.   /**
  1251.    * Updates the given MediaState.
  1252.    *
  1253.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1254.    * @return {?number} The number of seconds to wait until updating again or
  1255.    *   null if another update does not need to be scheduled.
  1256.    * @private
  1257.    */
  1258.   update_(mediaState) {
  1259.     goog.asserts.assert(this.manifest_, 'manifest_ should not be null');
  1260.     goog.asserts.assert(this.config_, 'config_ should not be null');
  1262.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1264.     // Do not schedule update for closed captions text mediastate, since closed
  1265.     // captions are embedded in video streams.
  1266.     if (shaka.media.StreamingEngine.isEmbeddedText_(mediaState)) {
  1267.       this.playerInterface_.mediaSourceEngine.setSelectedClosedCaptionId(
  1268.           mediaState.stream.originalId || '');
  1269.       return null;
  1270.     } else if (mediaState.type == ContentType.TEXT) {
  1271.       // Disable embedded captions if not desired (e.g. if transitioning from
  1272.       // embedded to not-embedded captions).
  1273.       this.playerInterface_.mediaSourceEngine.clearSelectedClosedCaptionId();
  1274.     }
  1276.     if (!this.playerInterface_.mediaSourceEngine.isStreamingAllowed() &&
  1277.         mediaState.type != ContentType.TEXT) {
  1278.       // It is not allowed to add segments yet, so we schedule an update to
  1279.       // check again later. So any prediction we make now could be terribly
  1280.       // invalid soon.
  1281.       return this.config_.updateIntervalSeconds / 2;
  1282.     }
  1284.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1286.     // Compute how far we've buffered ahead of the playhead.
  1287.     const presentationTime = this.playerInterface_.getPresentationTime();
  1289.     if (mediaState.type === ContentType.AUDIO) {
  1290.       // evict all prefetched segments that are before the presentationTime
  1291.       for (const stream of this.audioPrefetchMap_.keys()) {
  1292.         const prefetch = this.audioPrefetchMap_.get(stream);
  1293.         prefetch.evict(presentationTime, /* clearInitSegments= */ true);
  1294.         prefetch.prefetchSegmentsByTime(presentationTime);
  1295.       }
  1296.     }
  1298.     // Get the next timestamp we need.
  1299.     const timeNeeded = this.getTimeNeeded_(mediaState, presentationTime);
  1300.     shaka.log.v2(logPrefix, 'timeNeeded=' + timeNeeded);
  1302.     // Get the amount of content we have buffered, accounting for drift.  This
  1303.     // is only used to determine if we have meet the buffering goal.  This
  1304.     // should be the same method that PlayheadObserver uses.
  1305.     const bufferedAhead =
  1306.         this.playerInterface_.mediaSourceEngine.bufferedAheadOf(
  1307.             mediaState.type, presentationTime);
  1309.     shaka.log.v2(logPrefix,
  1310.         'update_:',
  1311.         'presentationTime=' + presentationTime,
  1312.         'bufferedAhead=' + bufferedAhead);
  1314.     const unscaledBufferingGoal = Math.max(
  1315.         this.manifest_.minBufferTime || 0,
  1316.         this.config_.rebufferingGoal,
  1317.         this.config_.bufferingGoal);
  1319.     const scaledBufferingGoal = Math.max(1,
  1320.         unscaledBufferingGoal * this.bufferingGoalScale_);
  1322.     // Check if we've buffered to the end of the presentation.
  1323.     const timeUntilEnd =
  1324.         this.manifest_.presentationTimeline.getDuration() - timeNeeded;
  1325.     const oneMicrosecond = 1e-6;
  1327.     const bufferEnd =
  1328.       this.playerInterface_.mediaSourceEngine.bufferEnd(mediaState.type);
  1330.     if (timeUntilEnd < oneMicrosecond && !!bufferEnd) {
  1331.       // We shouldn't rebuffer if the playhead is close to the end of the
  1332.       // presentation.
  1333.       shaka.log.debug(logPrefix, 'buffered to end of presentation');
  1334.       mediaState.endOfStream = true;
  1336.       if (mediaState.type == ContentType.VIDEO) {
  1337.         // Since the text stream of CEA closed captions doesn't have update
  1338.         // timer, we have to set the text endOfStream based on the video
  1339.         // stream's endOfStream state.
  1340.         const textState = this.mediaStates_.get(ContentType.TEXT);
  1341.         if (textState &&
  1342.             shaka.media.StreamingEngine.isEmbeddedText_(textState)) {
  1343.           textState.endOfStream = true;
  1344.         }
  1345.       }
  1346.       return null;
  1347.     }
  1348.     mediaState.endOfStream = false;
  1350.     // If we've buffered to the buffering goal then schedule an update.
  1351.     if (bufferedAhead >= scaledBufferingGoal) {
  1352.       shaka.log.v2(logPrefix, 'buffering goal met');
  1354.       // Do not try to predict the next update.  Just poll according to
  1355.       // configuration (seconds). The playback rate can change at any time, so
  1356.       // any prediction we make now could be terribly invalid soon.
  1357.       return this.config_.updateIntervalSeconds / 2;
  1358.     }
  1360.     const reference = this.getSegmentReferenceNeeded_(
  1361.         mediaState, presentationTime, bufferEnd);
  1362.     if (!reference) {
  1363.       // The segment could not be found, does not exist, or is not available.
  1364.       // In any case just try again... if the manifest is incomplete or is not
  1365.       // being updated then we'll idle forever; otherwise, we'll end up getting
  1366.       // a SegmentReference eventually.
  1367.       return this.config_.updateIntervalSeconds;
  1368.     }
  1370.     // Do not let any one stream get far ahead of any other.
  1371.     let minTimeNeeded = Infinity;
  1372.     const mediaStates = Array.from(this.mediaStates_.values());
  1373.     for (const otherState of mediaStates) {
  1374.       // Do not consider embedded captions in this calculation.  It could lead
  1375.       // to hangs in streaming.
  1376.       if (shaka.media.StreamingEngine.isEmbeddedText_(otherState)) {
  1377.         continue;
  1378.       }
  1379.       // If there is no next segment, ignore this stream.  This happens with
  1380.       // text when there's a Period with no text in it.
  1381.       if (otherState.segmentIterator && !otherState.segmentIterator.current()) {
  1382.         continue;
  1383.       }
  1385.       const timeNeeded = this.getTimeNeeded_(otherState, presentationTime);
  1386.       minTimeNeeded = Math.min(minTimeNeeded, timeNeeded);
  1387.     }
  1389.     const maxSegmentDuration =
  1390.         this.manifest_.presentationTimeline.getMaxSegmentDuration();
  1391.     const maxRunAhead = maxSegmentDuration *
  1392.         shaka.media.StreamingEngine.MAX_RUN_AHEAD_SEGMENTS_;
  1393.     if (timeNeeded >= minTimeNeeded + maxRunAhead) {
  1394.       // Wait and give other media types time to catch up to this one.
  1395.       // For example, let video buffering catch up to audio buffering before
  1396.       // fetching another audio segment.
  1397.       shaka.log.v2(logPrefix, 'waiting for other streams to buffer');
  1398.       return this.config_.updateIntervalSeconds;
  1399.     }
  1401.     if (mediaState.segmentPrefetch && mediaState.segmentIterator &&
  1402.         !this.audioPrefetchMap_.has(mediaState.stream)) {
  1403.       mediaState.segmentPrefetch.evict(presentationTime);
  1404.       mediaState.segmentPrefetch.prefetchSegmentsByTime(reference.startTime);
  1405.     }
  1407.     const p = this.fetchAndAppend_(mediaState, presentationTime, reference);
  1408.     p.catch(() => {});  // TODO(#1993): Handle asynchronous errors.
  1409.     return null;
  1410.   }
  1413.   /**
  1414.    * Gets the next timestamp needed. Returns the playhead's position if the
  1415.    * buffer is empty; otherwise, returns the time at which the last segment
  1416.    * appended ends.
  1417.    *
  1418.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1419.    * @param {number} presentationTime
  1420.    * @return {number} The next timestamp needed.
  1421.    * @private
  1422.    */
  1423.   getTimeNeeded_(mediaState, presentationTime) {
  1424.     // Get the next timestamp we need. We must use |lastSegmentReference|
  1425.     // to determine this and not the actual buffer for two reasons:
  1426.     //   1. Actual segments end slightly before their advertised end times, so
  1427.     //      the next timestamp we need is actually larger than |bufferEnd|.
  1428.     //   2. There may be drift (the timestamps in the segments are ahead/behind
  1429.     //      of the timestamps in the manifest), but we need drift-free times
  1430.     //      when comparing times against the presentation timeline.
  1431.     if (!mediaState.lastSegmentReference) {
  1432.       return presentationTime;
  1433.     }
  1435.     return mediaState.lastSegmentReference.endTime;
  1436.   }
  1439.   /**
  1440.    * Gets the SegmentReference of the next segment needed.
  1441.    *
  1442.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1443.    * @param {number} presentationTime
  1444.    * @param {?number} bufferEnd
  1445.    * @return {shaka.media.SegmentReference} The SegmentReference of the
  1446.    *   next segment needed. Returns null if a segment could not be found, does
  1447.    *   not exist, or is not available.
  1448.    * @private
  1449.    */
  1450.   getSegmentReferenceNeeded_(mediaState, presentationTime, bufferEnd) {
  1451.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1452.     goog.asserts.assert(
  1453.         mediaState.stream.segmentIndex,
  1454.         'segment index should have been generated already');
  1456.     if (mediaState.segmentIterator) {
  1457.       // Something is buffered from the same Stream.  Use the current position
  1458.       // in the segment index.  This is updated via next() after each segment is
  1459.       // appended.
  1460.       return mediaState.segmentIterator.current();
  1461.     } else if (mediaState.lastSegmentReference || bufferEnd) {
  1462.       // Something is buffered from another Stream.
  1463.       const time = mediaState.lastSegmentReference ?
  1464.           mediaState.lastSegmentReference.endTime :
  1465.           bufferEnd;
  1466.       goog.asserts.assert(time != null, 'Should have a time to search');
  1467.       shaka.log.v1(
  1468.           logPrefix, 'looking up segment from new stream endTime:', time);
  1470.       const reverse = this.playerInterface_.getPlaybackRate() < 0;
  1471.       mediaState.segmentIterator =
  1472.           mediaState.stream.segmentIndex.getIteratorForTime(
  1473.               time, /* allowNonIndepedent= */ false, reverse);
  1474.       const ref = mediaState.segmentIterator &&
  1475.           mediaState.segmentIterator.next().value;
  1476.       if (ref == null) {
  1477.         shaka.log.warning(logPrefix, 'cannot find segment', 'endTime:', time);
  1478.       }
  1479.       return ref;
  1480.     } else {
  1481.       // Nothing is buffered.  Start at the playhead time.
  1483.       // If there's positive drift then we need to adjust the lookup time, and
  1484.       // may wind up requesting the previous segment to be safe.
  1485.       // inaccurateManifestTolerance should be 0 for low latency streaming.
  1486.       const inaccurateTolerance = this.config_.inaccurateManifestTolerance;
  1487.       const lookupTime = Math.max(presentationTime - inaccurateTolerance, 0);
  1489.       shaka.log.v1(logPrefix, 'looking up segment',
  1490.           'lookupTime:', lookupTime,
  1491.           'presentationTime:', presentationTime);
  1493.       const reverse = this.playerInterface_.getPlaybackRate() < 0;
  1494.       let ref = null;
  1495.       if (inaccurateTolerance) {
  1496.         mediaState.segmentIterator =
  1497.             mediaState.stream.segmentIndex.getIteratorForTime(
  1498.                 lookupTime, /* allowNonIndepedent= */ false, reverse);
  1499.         ref = mediaState.segmentIterator &&
  1500.             mediaState.segmentIterator.next().value;
  1501.       }
  1502.       if (!ref) {
  1503.         // If we can't find a valid segment with the drifted time, look for a
  1504.         // segment with the presentation time.
  1505.         mediaState.segmentIterator =
  1506.             mediaState.stream.segmentIndex.getIteratorForTime(
  1507.                 presentationTime, /* allowNonIndepedent= */ false, reverse);
  1508.         ref = mediaState.segmentIterator &&
  1509.             mediaState.segmentIterator.next().value;
  1510.       }
  1511.       if (ref == null) {
  1512.         shaka.log.warning(logPrefix, 'cannot find segment',
  1513.             'lookupTime:', lookupTime,
  1514.             'presentationTime:', presentationTime);
  1515.       }
  1516.       return ref;
  1517.     }
  1518.   }
  1521.   /**
  1522.    * Fetches and appends the given segment. Sets up the given MediaState's
  1523.    * associated SourceBuffer and evicts segments if either are required
  1524.    * beforehand. Schedules another update after completing successfully.
  1525.    *
  1526.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  1527.    * @param {number} presentationTime
  1528.    * @param {!shaka.media.SegmentReference} reference
  1529.    * @private
  1530.    */
  1531.   async fetchAndAppend_(mediaState, presentationTime, reference) {
  1532.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1533.     const StreamingEngine = shaka.media.StreamingEngine;
  1534.     const logPrefix = StreamingEngine.logPrefix_(mediaState);
  1536.     shaka.log.v1(logPrefix,
  1537.         'fetchAndAppend_:',
  1538.         'presentationTime=' + presentationTime,
  1539.         'reference.startTime=' + reference.startTime,
  1540.         'reference.endTime=' + reference.endTime);
  1542.     // Subtlety: The playhead may move while asynchronous update operations are
  1543.     // in progress, so we should avoid calling playhead.getTime() in any
  1544.     // callbacks. Furthermore, switch() or seeked() may be called at any time,
  1545.     // so we store the old iterator.  This allows the mediaState to change and
  1546.     // we'll update the old iterator.
  1547.     const stream = mediaState.stream;
  1548.     const iter = mediaState.segmentIterator;
  1550.     mediaState.performingUpdate = true;
  1552.     try {
  1553.       if (reference.getStatus() ==
  1554.           shaka.media.SegmentReference.Status.MISSING) {
  1555.         throw new shaka.util.Error(
  1556.             shaka.util.Error.Severity.RECOVERABLE,
  1557.             shaka.util.Error.Category.NETWORK,
  1558.             shaka.util.Error.Code.SEGMENT_MISSING);
  1559.       }
  1560.       await this.initSourceBuffer_(mediaState, reference);
  1561.       this.destroyer_.ensureNotDestroyed();
  1562.       if (this.fatalError_) {
  1563.         return;
  1564.       }
  1566.       shaka.log.v2(logPrefix, 'fetching segment');
  1567.       const isMP4 = stream.mimeType == 'video/mp4' ||
  1568.               stream.mimeType == 'audio/mp4';
  1569.       const isReadableStreamSupported = window.ReadableStream;
  1570.       const lowLatencyMode = this.config_.lowLatencyMode &&
  1571.           this.manifest_.isLowLatency;
  1572.       // Enable MP4 low latency streaming with ReadableStream chunked data.
  1573.       // And only for DASH and HLS with byterange optimization.
  1574.       if (lowLatencyMode && isReadableStreamSupported && isMP4 &&
  1575.           (this.manifest_.type != shaka.media.ManifestParser.HLS ||
  1576.           reference.hasByterangeOptimization())) {
  1577.         let remaining = new Uint8Array(0);
  1578.         let processingResult = false;
  1579.         let callbackCalled = false;
  1580.         let streamDataCallbackError;
  1581.         const streamDataCallback = async (data) => {
  1582.           if (processingResult) {
  1583.             // If the fallback result processing was triggered, don't also
  1584.             // append the buffer here.  In theory this should never happen,
  1585.             // but it does on some older TVs.
  1586.             return;
  1587.           }
  1588.           callbackCalled = true;
  1589.           this.destroyer_.ensureNotDestroyed();
  1590.           if (this.fatalError_) {
  1591.             return;
  1592.           }
  1593.           try {
  1594.             // Append the data with complete boxes.
  1595.             // Every time streamDataCallback gets called, append the new data
  1596.             // to the remaining data.
  1597.             // Find the last fully completed Mdat box, and slice the data into
  1598.             // two parts: the first part with completed Mdat boxes, and the
  1599.             // second part with an incomplete box.
  1600.             // Append the first part, and save the second part as remaining
  1601.             // data, and handle it with the next streamDataCallback call.
  1602.             remaining = this.concatArray_(remaining, data);
  1603.             let sawMDAT = false;
  1604.             let offset = 0;
  1605.             new shaka.util.Mp4Parser()
  1606.                 .box('mdat', (box) => {
  1607.                   offset = box.size + box.start;
  1608.                   sawMDAT = true;
  1609.                 })
  1610.                 .parse(remaining, /* partialOkay= */ false,
  1611.                     /* isChunkedData= */ true);
  1612.             if (sawMDAT) {
  1613.               const dataToAppend = remaining.subarray(0, offset);
  1614.               remaining = remaining.subarray(offset);
  1615.               await this.append_(
  1616.                   mediaState, presentationTime, stream, reference, dataToAppend,
  1617.                   /* isChunkedData= */ true);
  1619.               if (mediaState.segmentPrefetch && mediaState.segmentIterator) {
  1620.                 mediaState.segmentPrefetch.prefetchSegmentsByTime(
  1621.                     reference.startTime, /* skipFirst= */ true);
  1622.               }
  1623.             }
  1624.           } catch (error) {
  1625.             streamDataCallbackError = error;
  1626.           }
  1627.         };
  1629.         const result =
  1630.             await this.fetch_(mediaState, reference, streamDataCallback);
  1631.         if (streamDataCallbackError) {
  1632.           throw streamDataCallbackError;
  1633.         }
  1634.         if (!callbackCalled) {
  1635.           // In some environments, we might be forced to use network plugins
  1636.           // that don't support streamDataCallback. In those cases, as a
  1637.           // fallback, append the buffer here.
  1638.           processingResult = true;
  1639.           this.destroyer_.ensureNotDestroyed();
  1640.           if (this.fatalError_) {
  1641.             return;
  1642.           }
  1644.           // If the text stream gets switched between fetch_() and append_(),
  1645.           // the new text parser is initialized, but the new init segment is
  1646.           // not fetched yet.  That would cause an error in
  1647.           // TextParser.parseMedia().
  1648.           // See http://b/168253400
  1649.           if (mediaState.waitingToClearBuffer) {
  1650.             shaka.log.info(logPrefix, 'waitingToClearBuffer, skip append');
  1651.             mediaState.performingUpdate = false;
  1652.             this.scheduleUpdate_(mediaState, 0);
  1653.             return;
  1654.           }
  1656.           await this.append_(
  1657.               mediaState, presentationTime, stream, reference, result);
  1658.         }
  1660.         if (mediaState.segmentPrefetch && mediaState.segmentIterator) {
  1661.           mediaState.segmentPrefetch.prefetchSegmentsByTime(
  1662.               reference.startTime, /* skipFirst= */ true);
  1663.         }
  1664.       } else {
  1665.         if (lowLatencyMode && !isReadableStreamSupported) {
  1666.           shaka.log.warning('Low latency streaming mode is enabled, but ' +
  1667.             'ReadableStream is not supported by the browser.');
  1668.         }
  1669.         const fetchSegment = this.fetch_(mediaState, reference);
  1670.         const result = await fetchSegment;
  1671.         this.destroyer_.ensureNotDestroyed();
  1672.         if (this.fatalError_) {
  1673.           return;
  1674.         }
  1675.         this.destroyer_.ensureNotDestroyed();
  1677.         // If the text stream gets switched between fetch_() and append_(), the
  1678.         // new text parser is initialized, but the new init segment is not
  1679.         // fetched yet.  That would cause an error in TextParser.parseMedia().
  1680.         // See http://b/168253400
  1681.         if (mediaState.waitingToClearBuffer) {
  1682.           shaka.log.info(logPrefix, 'waitingToClearBuffer, skip append');
  1683.           mediaState.performingUpdate = false;
  1684.           this.scheduleUpdate_(mediaState, 0);
  1685.           return;
  1686.         }
  1688.         await this.append_(
  1689.             mediaState, presentationTime, stream, reference, result);
  1690.       }
  1692.       this.destroyer_.ensureNotDestroyed();
  1693.       if (this.fatalError_) {
  1694.         return;
  1695.       }
  1696.       // move to next segment after appending the current segment.
  1697.       mediaState.lastSegmentReference = reference;
  1698.       const newRef = iter.next().value;
  1699.       shaka.log.v2(logPrefix, 'advancing to next segment', newRef);
  1701.       mediaState.performingUpdate = false;
  1702.       mediaState.recovering = false;
  1704.       const info = this.playerInterface_.mediaSourceEngine.getBufferedInfo();
  1705.       const buffered = info[mediaState.type];
  1706.       // Convert the buffered object to a string capture its properties on
  1707.       // WebOS.
  1708.       shaka.log.v1(logPrefix, 'finished fetch and append',
  1709.           JSON.stringify(buffered));
  1711.       if (!mediaState.waitingToClearBuffer) {
  1712.         this.playerInterface_.onSegmentAppended(reference, mediaState.stream);
  1713.       }
  1715.       // Update right away.
  1716.       this.scheduleUpdate_(mediaState, 0);
  1717.     } catch (error) {
  1718.       this.destroyer_.ensureNotDestroyed(error);
  1719.       if (this.fatalError_) {
  1720.         return;
  1721.       }
  1722.       goog.asserts.assert(error instanceof shaka.util.Error,
  1723.           'Should only receive a Shaka error');
  1725.       mediaState.performingUpdate = false;
  1727.       if (error.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  1728.         // If the network slows down, abort the current fetch request and start
  1729.         // a new one, and ignore the error message.
  1730.         mediaState.performingUpdate = false;
  1731.         this.cancelUpdate_(mediaState);
  1732.         this.scheduleUpdate_(mediaState, 0);
  1733.       } else if (mediaState.type == ContentType.TEXT &&
  1734.           this.config_.ignoreTextStreamFailures) {
  1735.         if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS) {
  1736.           shaka.log.warning(logPrefix,
  1737.               'Text stream failed to download. Proceeding without it.');
  1738.         } else {
  1739.           shaka.log.warning(logPrefix,
  1740.               'Text stream failed to parse. Proceeding without it.');
  1741.         }
  1742.         this.mediaStates_.delete(ContentType.TEXT);
  1743.       } else if (error.code == shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR) {
  1744.         this.handleQuotaExceeded_(mediaState, error);
  1745.       } else {
  1746.         shaka.log.error(logPrefix, 'failed fetch and append: code=' +
  1747.             error.code);
  1748.         mediaState.hasError = true;
  1750.         if (error.category == shaka.util.Error.Category.NETWORK &&
  1751.             mediaState.segmentPrefetch) {
  1752.           mediaState.segmentPrefetch.removeReference(reference);
  1753.         }
  1755.         error.severity = shaka.util.Error.Severity.CRITICAL;
  1756.         await this.handleStreamingError_(mediaState, error);
  1757.       }
  1758.     }
  1759.   }
  1761.   /**
  1762.    * @param {!BufferSource} rawResult
  1763.    * @param {shaka.extern.aesKey} aesKey
  1764.    * @param {number} position
  1765.    * @return {!Promise.<!BufferSource>} finalResult
  1766.    * @private
  1767.    */
  1768.   async aesDecrypt_(rawResult, aesKey, position) {
  1769.     const key = aesKey;
  1770.     if (!key.cryptoKey) {
  1771.       goog.asserts.assert(key.fetchKey, 'If AES cryptoKey was not ' +
  1772.           'preloaded, fetchKey function should be provided');
  1773.       await key.fetchKey();
  1774.       goog.asserts.assert(key.cryptoKey, 'AES cryptoKey should now be set');
  1775.     }
  1776.     let iv = key.iv;
  1777.     if (!iv) {
  1778.       iv = shaka.util.BufferUtils.toUint8(new ArrayBuffer(16));
  1779.       let sequence = key.firstMediaSequenceNumber + position;
  1780.       for (let i = iv.byteLength - 1; i >= 0; i--) {
  1781.         iv[i] = sequence & 0xff;
  1782.         sequence >>= 8;
  1783.       }
  1784.     }
  1785.     let algorithm;
  1786.     if (aesKey.blockCipherMode == 'CBC') {
  1787.       algorithm = {
  1788.         name: 'AES-CBC',
  1789.         iv,
  1790.       };
  1791.     } else {
  1792.       algorithm = {
  1793.         name: 'AES-CTR',
  1794.         counter: iv,
  1795.         // NIST SP800-38A standard suggests that the counter should occupy half
  1796.         // of the counter block
  1797.         length: 64,
  1798.       };
  1799.     }
  1800.     return window.crypto.subtle.decrypt(algorithm, key.cryptoKey, rawResult);
  1801.   }
  1804.   /**
  1805.    * Clear per-stream error states and retry any failed streams.
  1806.    * @param {number} delaySeconds
  1807.    * @return {boolean} False if unable to retry.
  1808.    */
  1809.   retry(delaySeconds) {
  1810.     if (this.destroyer_.destroyed()) {
  1811.       shaka.log.error('Unable to retry after StreamingEngine is destroyed!');
  1812.       return false;
  1813.     }
  1815.     if (this.fatalError_) {
  1816.       shaka.log.error('Unable to retry after StreamingEngine encountered a ' +
  1817.                       'fatal error!');
  1818.       return false;
  1819.     }
  1821.     for (const mediaState of this.mediaStates_.values()) {
  1822.       const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1823.       // Only schedule an update if it has an error, but it's not mid-update
  1824.       // and there is not already an update scheduled.
  1825.       if (mediaState.hasError && !mediaState.performingUpdate &&
  1826.           !mediaState.updateTimer) {
  1827.         shaka.log.info(logPrefix, 'Retrying after failure...');
  1828.         mediaState.hasError = false;
  1829.         this.scheduleUpdate_(mediaState, delaySeconds);
  1830.       }
  1831.     }
  1833.     return true;
  1834.   }
  1837.   /**
  1838.    * Append the data to the remaining data.
  1839.    * @param {!Uint8Array} remaining
  1840.    * @param {!Uint8Array} data
  1841.    * @return {!Uint8Array}
  1842.    * @private
  1843.    */
  1844.   concatArray_(remaining, data) {
  1845.     const result = new Uint8Array(remaining.length + data.length);
  1846.     result.set(remaining);
  1847.     result.set(data, remaining.length);
  1848.     return result;
  1849.   }
  1852.   /**
  1853.    * Handles a QUOTA_EXCEEDED_ERROR.
  1854.    *
  1855.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1856.    * @param {!shaka.util.Error} error
  1857.    * @private
  1858.    */
  1859.   handleQuotaExceeded_(mediaState, error) {
  1860.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  1862.     // The segment cannot fit into the SourceBuffer. Ideally, MediaSource would
  1863.     // have evicted old data to accommodate the segment; however, it may have
  1864.     // failed to do this if the segment is very large, or if it could not find
  1865.     // a suitable time range to remove.
  1866.     //
  1867.     // We can overcome the latter by trying to append the segment again;
  1868.     // however, to avoid continuous QuotaExceededErrors we must reduce the size
  1869.     // of the buffer going forward.
  1870.     //
  1871.     // If we've recently reduced the buffering goals, wait until the stream
  1872.     // which caused the first QuotaExceededError recovers. Doing this ensures
  1873.     // we don't reduce the buffering goals too quickly.
  1875.     const mediaStates = Array.from(this.mediaStates_.values());
  1876.     const waitingForAnotherStreamToRecover = mediaStates.some((ms) => {
  1877.       return ms != mediaState && ms.recovering;
  1878.     });
  1880.     if (!waitingForAnotherStreamToRecover) {
  1881.       if (this.config_.maxDisabledTime > 0) {
  1882.         const handled = this.playerInterface_.disableStream(
  1883.             mediaState.stream, this.config_.maxDisabledTime);
  1884.         if (handled) {
  1885.           return;
  1886.         }
  1887.       }
  1888.       // Reduction schedule: 80%, 60%, 40%, 20%, 16%, 12%, 8%, 4%, fail.
  1889.       // Note: percentages are used for comparisons to avoid rounding errors.
  1890.       const percentBefore = Math.round(100 * this.bufferingGoalScale_);
  1891.       if (percentBefore > 20) {
  1892.         this.bufferingGoalScale_ -= 0.2;
  1893.       } else if (percentBefore > 4) {
  1894.         this.bufferingGoalScale_ -= 0.04;
  1895.       } else {
  1896.         shaka.log.error(
  1897.             logPrefix, 'MediaSource threw QuotaExceededError too many times');
  1898.         mediaState.hasError = true;
  1899.         this.fatalError_ = true;
  1900.         this.playerInterface_.onError(error);
  1901.         return;
  1902.       }
  1903.       const percentAfter = Math.round(100 * this.bufferingGoalScale_);
  1904.       shaka.log.warning(
  1905.           logPrefix,
  1906.           'MediaSource threw QuotaExceededError:',
  1907.           'reducing buffering goals by ' + (100 - percentAfter) + '%');
  1908.       mediaState.recovering = true;
  1909.     } else {
  1910.       shaka.log.debug(
  1911.           logPrefix,
  1912.           'MediaSource threw QuotaExceededError:',
  1913.           'waiting for another stream to recover...');
  1914.     }
  1916.     // QuotaExceededError gets thrown if eviction didn't help to make room
  1917.     // for a segment. We want to wait for a while (4 seconds is just an
  1918.     // arbitrary number) before updating to give the playhead a chance to
  1919.     // advance, so we don't immediately throw again.
  1920.     this.scheduleUpdate_(mediaState, 4);
  1921.   }
  1924.   /**
  1925.    * Sets the given MediaState's associated SourceBuffer's timestamp offset,
  1926.    * append window, and init segment if they have changed. If an error occurs
  1927.    * then neither the timestamp offset or init segment are unset, since another
  1928.    * call to switch() will end up superseding them.
  1929.    *
  1930.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  1931.    * @param {!shaka.media.SegmentReference} reference
  1932.    * @return {!Promise}
  1933.    * @private
  1934.    */
  1935.   async initSourceBuffer_(mediaState, reference) {
  1936.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1937.     const MimeUtils = shaka.util.MimeUtils;
  1938.     const StreamingEngine = shaka.media.StreamingEngine;
  1939.     const logPrefix = StreamingEngine.logPrefix_(mediaState);
  1941.     /** @type {!Array.<!Promise>} */
  1942.     const operations = [];
  1944.     // Rounding issues can cause us to remove the first frame of a Period, so
  1945.     // reduce the window start time slightly.
  1946.     const appendWindowStart = Math.max(0,
  1947.         Math.max(reference.appendWindowStart, this.playRangeStart_) -
  1948.         StreamingEngine.APPEND_WINDOW_START_FUDGE_);
  1949.     const appendWindowEnd =
  1950.         Math.min(reference.appendWindowEnd, this.playRangeEnd_) +
  1951.         StreamingEngine.APPEND_WINDOW_END_FUDGE_;
  1953.     goog.asserts.assert(
  1954.         reference.startTime <= appendWindowEnd,
  1955.         logPrefix + ' segment should start before append window end');
  1957.     const codecs = MimeUtils.getCodecBase(mediaState.stream.codecs);
  1958.     const mimeType = MimeUtils.getBasicType(mediaState.stream.mimeType);
  1959.     const timestampOffset = reference.timestampOffset;
  1960.     if (timestampOffset != mediaState.lastTimestampOffset ||
  1961.         appendWindowStart != mediaState.lastAppendWindowStart ||
  1962.         appendWindowEnd != mediaState.lastAppendWindowEnd ||
  1963.         codecs != mediaState.lastCodecs ||
  1964.         mimeType != mediaState.lastMimeType) {
  1965.       shaka.log.v1(logPrefix, 'setting timestamp offset to ' + timestampOffset);
  1966.       shaka.log.v1(logPrefix,
  1967.           'setting append window start to ' + appendWindowStart);
  1968.       shaka.log.v1(logPrefix,
  1969.           'setting append window end to ' + appendWindowEnd);
  1971.       const isResetMediaSourceNecessary =
  1972.           mediaState.lastCodecs && mediaState.lastMimeType &&
  1973.           this.playerInterface_.mediaSourceEngine.isResetMediaSourceNecessary(
  1974.               mediaState.type, mediaState.stream, mimeType, codecs);
  1975.       if (isResetMediaSourceNecessary) {
  1976.         let otherState = null;
  1977.         if (mediaState.type === ContentType.VIDEO) {
  1978.           otherState = this.mediaStates_.get(ContentType.AUDIO);
  1979.         } else if (mediaState.type === ContentType.AUDIO) {
  1980.           otherState = this.mediaStates_.get(ContentType.VIDEO);
  1981.         }
  1982.         if (otherState) {
  1983.           // First, abort all operations in progress on the other stream.
  1984.           await this.abortOperations_(otherState).catch(() => {});
  1985.           // Then clear our cache of the last init segment, since MSE will be
  1986.           // reloaded and no init segment will be there post-reload.
  1987.           otherState.lastInitSegmentReference = null;
  1988.           // Now force the existing buffer to be cleared.  It is not necessary
  1989.           // to perform the MSE clear operation, but this has the side-effect
  1990.           // that our state for that stream will then match MSE's post-reload
  1991.           // state.
  1992.           this.forceClearBuffer_(otherState);
  1993.         }
  1994.       }
  1996.       // Dispatching init asynchronously causes the sourceBuffers in
  1997.       // the MediaSourceEngine to become detached do to race conditions
  1998.       // with mediaSource and sourceBuffers being created simultaneously.
  1999.       await this.setProperties_(mediaState, timestampOffset, appendWindowStart,
  2000.           appendWindowEnd, reference, codecs, mimeType);
  2001.     }
  2003.     if (!shaka.media.InitSegmentReference.equal(
  2004.         reference.initSegmentReference, mediaState.lastInitSegmentReference)) {
  2005.       mediaState.lastInitSegmentReference = reference.initSegmentReference;
  2007.       if (reference.isIndependent() && reference.initSegmentReference) {
  2008.         shaka.log.v1(logPrefix, 'fetching init segment');
  2010.         const fetchInit =
  2011.             this.fetch_(mediaState, reference.initSegmentReference);
  2012.         const append = async () => {
  2013.           try {
  2014.             const initSegment = await fetchInit;
  2015.             this.destroyer_.ensureNotDestroyed();
  2017.             let lastTimescale = null;
  2018.             const timescaleMap = new Map();
  2020.             /** @type {!shaka.extern.SpatialVideoInfo} */
  2021.             const spatialVideoInfo = {
  2022.               projection: null,
  2023.               hfov: null,
  2024.             };
  2026.             const parser = new shaka.util.Mp4Parser();
  2027.             const Mp4Parser = shaka.util.Mp4Parser;
  2028.             const Mp4BoxParsers = shaka.util.Mp4BoxParsers;
  2029.             parser.box('moov', Mp4Parser.children)
  2030.                 .box('trak', Mp4Parser.children)
  2031.                 .box('mdia', Mp4Parser.children)
  2032.                 .fullBox('mdhd', (box) => {
  2033.                   goog.asserts.assert(
  2034.                       box.version != null,
  2035.                       'MDHD is a full box and should have a valid version.');
  2036.                   const parsedMDHDBox = Mp4BoxParsers.parseMDHD(
  2037.                       box.reader, box.version);
  2038.                   lastTimescale = parsedMDHDBox.timescale;
  2039.                 })
  2040.                 .box('hdlr', (box) => {
  2041.                   const parsedHDLR = Mp4BoxParsers.parseHDLR(box.reader);
  2042.                   switch (parsedHDLR.handlerType) {
  2043.                     case 'soun':
  2044.                       timescaleMap.set(ContentType.AUDIO, lastTimescale);
  2045.                       break;
  2046.                     case 'vide':
  2047.                       timescaleMap.set(ContentType.VIDEO, lastTimescale);
  2048.                       break;
  2049.                   }
  2050.                   lastTimescale = null;
  2051.                 })
  2052.                 .box('minf', Mp4Parser.children)
  2053.                 .box('stbl', Mp4Parser.children)
  2054.                 .fullBox('stsd', Mp4Parser.sampleDescription)
  2055.                 .box('encv', Mp4Parser.visualSampleEntry)
  2056.                 .box('avc1', Mp4Parser.visualSampleEntry)
  2057.                 .box('avc3', Mp4Parser.visualSampleEntry)
  2058.                 .box('hev1', Mp4Parser.visualSampleEntry)
  2059.                 .box('hvc1', Mp4Parser.visualSampleEntry)
  2060.                 .box('dvav', Mp4Parser.visualSampleEntry)
  2061.                 .box('dva1', Mp4Parser.visualSampleEntry)
  2062.                 .box('dvh1', Mp4Parser.visualSampleEntry)
  2063.                 .box('dvhe', Mp4Parser.visualSampleEntry)
  2064.                 .box('vexu', Mp4Parser.children)
  2065.                 .box('proj', Mp4Parser.children)
  2066.                 .fullBox('prji', (box) => {
  2067.                   const parsedPRJIBox = Mp4BoxParsers.parsePRJI(box.reader);
  2068.                   spatialVideoInfo.projection = parsedPRJIBox.projection;
  2069.                 })
  2070.                 .box('hfov', (box) => {
  2071.                   const parsedHFOVBox = Mp4BoxParsers.parseHFOV(box.reader);
  2072.                   spatialVideoInfo.hfov = parsedHFOVBox.hfov;
  2073.                 })
  2074.                 .parse(initSegment);
  2076.             this.updateSpatialVideoInfo_(spatialVideoInfo);
  2078.             if (timescaleMap.has(mediaState.type)) {
  2079.               reference.initSegmentReference.timescale =
  2080.                   timescaleMap.get(mediaState.type);
  2081.             } else if (lastTimescale != null) {
  2082.               // Fallback for segments without HDLR box
  2083.               reference.initSegmentReference.timescale = lastTimescale;
  2084.             }
  2086.             shaka.log.v1(logPrefix, 'appending init segment');
  2087.             const hasClosedCaptions = mediaState.stream.closedCaptions &&
  2088.                 mediaState.stream.closedCaptions.size > 0;
  2089.             await this.playerInterface_.beforeAppendSegment(
  2090.                 mediaState.type, initSegment);
  2091.             await this.playerInterface_.mediaSourceEngine.appendBuffer(
  2092.                 mediaState.type, initSegment, /* reference= */ null,
  2093.                 mediaState.stream, hasClosedCaptions);
  2094.           } catch (error) {
  2095.             mediaState.lastInitSegmentReference = null;
  2096.             throw error;
  2097.           }
  2098.         };
  2099.         this.playerInterface_.onInitSegmentAppended(
  2100.             reference.startTime, reference.initSegmentReference);
  2101.         operations.push(append());
  2102.       }
  2103.     }
  2105.     if (this.manifest_.sequenceMode) {
  2106.       const lastDiscontinuitySequence =
  2107.           mediaState.lastSegmentReference ?
  2108.               mediaState.lastSegmentReference.discontinuitySequence : null;
  2109.       // Across discontinuity bounds, we should resync timestamps for
  2110.       // sequence mode playbacks.  The next segment appended should
  2111.       // land at its theoretical timestamp from the segment index.
  2112.       if (reference.discontinuitySequence != lastDiscontinuitySequence) {
  2113.         operations.push(this.playerInterface_.mediaSourceEngine.resync(
  2114.             mediaState.type, reference.startTime));
  2115.       }
  2116.     }
  2118.     await Promise.all(operations);
  2119.   }
  2121.   /**
  2122.    *
  2123.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  2124.    * @param {number} timestampOffset
  2125.    * @param {number} appendWindowStart
  2126.    * @param {number} appendWindowEnd
  2127.    * @param {!shaka.media.SegmentReference} reference
  2128.    * @param {?string=} codecs
  2129.    * @param {?string=} mimeType
  2130.    * @private
  2131.    */
  2132.   async setProperties_(mediaState, timestampOffset, appendWindowStart,
  2133.       appendWindowEnd, reference, codecs, mimeType) {
  2134.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2136.     /**
  2137.      * @type {!Map.<shaka.util.ManifestParserUtils.ContentType,
  2138.      *              shaka.extern.Stream>}
  2139.      */
  2140.     const streamsByType = new Map();
  2141.     if (this.currentVariant_.audio) {
  2142.       streamsByType.set(ContentType.AUDIO, this.currentVariant_.audio);
  2143.     }
  2144.     if (this.currentVariant_.video) {
  2145.       streamsByType.set(ContentType.VIDEO, this.currentVariant_.video);
  2146.     }
  2147.     try {
  2148.       mediaState.lastAppendWindowStart = appendWindowStart;
  2149.       mediaState.lastAppendWindowEnd = appendWindowEnd;
  2150.       if (codecs) {
  2151.         mediaState.lastCodecs = codecs;
  2152.       }
  2153.       if (mimeType) {
  2154.         mediaState.lastMimeType = mimeType;
  2155.       }
  2156.       mediaState.lastTimestampOffset = timestampOffset;
  2158.       const ignoreTimestampOffset = this.manifest_.sequenceMode ||
  2159.           this.manifest_.type == shaka.media.ManifestParser.HLS;
  2161.       await this.playerInterface_.mediaSourceEngine.setStreamProperties(
  2162.           mediaState.type, timestampOffset, appendWindowStart,
  2163.           appendWindowEnd, ignoreTimestampOffset,
  2164.           reference.mimeType || mediaState.stream.mimeType,
  2165.           reference.codecs || mediaState.stream.codecs, streamsByType);
  2166.     } catch (error) {
  2167.       mediaState.lastAppendWindowStart = null;
  2168.       mediaState.lastAppendWindowEnd = null;
  2169.       mediaState.lastCodecs = null;
  2170.       mediaState.lastMimeType = null;
  2171.       mediaState.lastTimestampOffset = null;
  2173.       throw error;
  2174.     }
  2175.   }
  2178.   /**
  2179.    * Appends the given segment and evicts content if required to append.
  2180.    *
  2181.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  2182.    * @param {number} presentationTime
  2183.    * @param {shaka.extern.Stream} stream
  2184.    * @param {!shaka.media.SegmentReference} reference
  2185.    * @param {BufferSource} segment
  2186.    * @param {boolean=} isChunkedData
  2187.    * @return {!Promise}
  2188.    * @private
  2189.    */
  2190.   async append_(mediaState, presentationTime, stream, reference, segment,
  2191.       isChunkedData = false) {
  2192.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  2194.     const hasClosedCaptions = stream.closedCaptions &&
  2195.         stream.closedCaptions.size > 0;
  2197.     let parser;
  2198.     const hasEmsg = ((stream.emsgSchemeIdUris != null &&
  2199.       stream.emsgSchemeIdUris.length > 0) ||
  2200.       this.config_.dispatchAllEmsgBoxes);
  2201.     const shouldParsePrftBox =
  2202.       (this.config_.parsePrftBox && !this.parsedPrftEventRaised_);
  2204.     const isMP4 = stream.mimeType == 'video/mp4' ||
  2205.             stream.mimeType == 'audio/mp4';
  2206.     let timescale = null;
  2207.     if (reference.initSegmentReference) {
  2208.       timescale = reference.initSegmentReference.timescale;
  2209.     }
  2210.     const shouldFixTimestampOffset = isMP4 && timescale &&
  2211.         stream.type === shaka.util.ManifestParserUtils.ContentType.VIDEO &&
  2212.         this.manifest_.type == shaka.media.ManifestParser.DASH &&
  2213.         this.config_.shouldFixTimestampOffset;
  2215.     if (hasEmsg || shouldParsePrftBox || shouldFixTimestampOffset) {
  2216.       parser = new shaka.util.Mp4Parser();
  2217.     }
  2219.     if (hasEmsg) {
  2220.       parser
  2221.           .fullBox(
  2222.               'emsg',
  2223.               (box) => this.parseEMSG_(
  2224.                   reference, stream.emsgSchemeIdUris, box));
  2225.     }
  2227.     if (shouldParsePrftBox) {
  2228.       parser
  2229.           .fullBox(
  2230.               'prft',
  2231.               (box) => this.parsePrft_(
  2232.                   reference, box));
  2233.     }
  2235.     if (shouldFixTimestampOffset) {
  2236.       parser
  2237.           .box('moof', shaka.util.Mp4Parser.children)
  2238.           .box('traf', shaka.util.Mp4Parser.children)
  2239.           .fullBox('tfdt', async (box) => {
  2240.             goog.asserts.assert(
  2241.                 box.version != null,
  2242.                 'TFDT is a full box and should have a valid version.');
  2244.             const parsedTFDT = shaka.util.Mp4BoxParsers.parseTFDTInaccurate(
  2245.                 box.reader, box.version);
  2247.             const baseMediaDecodeTime = parsedTFDT.baseMediaDecodeTime;
  2249.             // In case the time is 0, it is not updated
  2250.             if (!baseMediaDecodeTime) {
  2251.               return;
  2252.             }
  2253.             goog.asserts.assert(typeof(timescale) == 'number',
  2254.                 'Should be an number!');
  2256.             const scaledMediaDecodeTime = -baseMediaDecodeTime / timescale;
  2258.             const comparison1 = Number(mediaState.lastTimestampOffset) || 0;
  2260.             if (comparison1 < scaledMediaDecodeTime) {
  2261.               const lastAppendWindowStart = mediaState.lastAppendWindowStart;
  2262.               const lastAppendWindowEnd = mediaState.lastAppendWindowEnd;
  2263.               goog.asserts.assert(typeof(lastAppendWindowStart) == 'number',
  2264.                   'Should be an number!');
  2265.               goog.asserts.assert(typeof(lastAppendWindowEnd) == 'number',
  2266.                   'Should be an number!');
  2267.               await this.setProperties_(mediaState, scaledMediaDecodeTime,
  2268.                   lastAppendWindowStart, lastAppendWindowEnd, reference);
  2269.             }
  2270.           });
  2271.     }
  2273.     if (hasEmsg || shouldParsePrftBox || shouldFixTimestampOffset) {
  2274.       parser.parse(segment, /* partialOkay= */ false, isChunkedData);
  2275.     }
  2277.     await this.evict_(mediaState, presentationTime);
  2278.     this.destroyer_.ensureNotDestroyed();
  2280.     // 'seeked' or 'adaptation' triggered logic applies only to this
  2281.     // appendBuffer() call.
  2282.     const seeked = mediaState.seeked;
  2283.     mediaState.seeked = false;
  2284.     const adaptation = mediaState.adaptation;
  2285.     mediaState.adaptation = false;
  2287.     await this.playerInterface_.beforeAppendSegment(mediaState.type, segment);
  2288.     await this.playerInterface_.mediaSourceEngine.appendBuffer(
  2289.         mediaState.type,
  2290.         segment,
  2291.         reference,
  2292.         stream,
  2293.         hasClosedCaptions,
  2294.         seeked,
  2295.         adaptation,
  2296.         isChunkedData);
  2297.     this.destroyer_.ensureNotDestroyed();
  2298.     shaka.log.v2(logPrefix, 'appended media segment');
  2299.   }
  2302.   /**
  2303.    * Parse the EMSG box from a MP4 container.
  2304.    *
  2305.    * @param {!shaka.media.SegmentReference} reference
  2306.    * @param {?Array.<string>} emsgSchemeIdUris Array of emsg
  2307.    *     scheme_id_uri for which emsg boxes should be parsed.
  2308.    * @param {!shaka.extern.ParsedBox} box
  2309.    * @private
  2310.    * https://dashif-documents.azurewebsites.net/Events/master/event.html#emsg-format
  2311.    * aligned(8) class DASHEventMessageBox
  2312.    *    extends FullBox(‘emsg’, version, flags = 0){
  2313.    * if (version==0) {
  2314.    *   string scheme_id_uri;
  2315.    *   string value;
  2316.    *   unsigned int(32) timescale;
  2317.    *   unsigned int(32) presentation_time_delta;
  2318.    *   unsigned int(32) event_duration;
  2319.    *   unsigned int(32) id;
  2320.    * } else if (version==1) {
  2321.    *   unsigned int(32) timescale;
  2322.    *   unsigned int(64) presentation_time;
  2323.    *   unsigned int(32) event_duration;
  2324.    *   unsigned int(32) id;
  2325.    *   string scheme_id_uri;
  2326.    *   string value;
  2327.    * }
  2328.    * unsigned int(8) message_data[];
  2329.    */
  2330.   parseEMSG_(reference, emsgSchemeIdUris, box) {
  2331.     let timescale;
  2332.     let id;
  2333.     let eventDuration;
  2334.     let schemeId;
  2335.     let startTime;
  2336.     let presentationTimeDelta;
  2337.     let value;
  2339.     if (box.version === 0) {
  2340.       schemeId = box.reader.readTerminatedString();
  2341.       value = box.reader.readTerminatedString();
  2342.       timescale = box.reader.readUint32();
  2343.       presentationTimeDelta = box.reader.readUint32();
  2344.       eventDuration = box.reader.readUint32();
  2345.       id = box.reader.readUint32();
  2346.       startTime = reference.startTime + (presentationTimeDelta / timescale);
  2347.     } else {
  2348.       timescale = box.reader.readUint32();
  2349.       const pts = box.reader.readUint64();
  2350.       startTime = (pts / timescale) + reference.timestampOffset;
  2351.       presentationTimeDelta = startTime - reference.startTime;
  2352.       eventDuration = box.reader.readUint32();
  2353.       id = box.reader.readUint32();
  2354.       schemeId = box.reader.readTerminatedString();
  2355.       value = box.reader.readTerminatedString();
  2356.     }
  2357.     const messageData = box.reader.readBytes(
  2358.         box.reader.getLength() - box.reader.getPosition());
  2360.     // See DASH sec. 5.10.3.3.1
  2361.     // If a DASH client detects an event message box with a scheme that is not
  2362.     // defined in MPD, the client is expected to ignore it.
  2363.     if ((emsgSchemeIdUris && emsgSchemeIdUris.includes(schemeId)) ||
  2364.         this.config_.dispatchAllEmsgBoxes) {
  2365.       // See DASH sec. 5.10.4.1
  2366.       // A special scheme in DASH used to signal manifest updates.
  2367.       if (schemeId == 'urn:mpeg:dash:event:2012') {
  2368.         this.playerInterface_.onManifestUpdate();
  2369.       } else {
  2370.         // All other schemes are dispatched as a general 'emsg' event.
  2371.         /** @type {shaka.extern.EmsgInfo} */
  2372.         const emsg = {
  2373.           startTime: startTime,
  2374.           endTime: startTime + (eventDuration / timescale),
  2375.           schemeIdUri: schemeId,
  2376.           value: value,
  2377.           timescale: timescale,
  2378.           presentationTimeDelta: presentationTimeDelta,
  2379.           eventDuration: eventDuration,
  2380.           id: id,
  2381.           messageData: messageData,
  2382.         };
  2384.         // Dispatch an event to notify the application about the emsg box.
  2385.         const eventName = shaka.util.FakeEvent.EventName.Emsg;
  2386.         const data = (new Map()).set('detail', emsg);
  2387.         const event = new shaka.util.FakeEvent(eventName, data);
  2388.         // A user can call preventDefault() on a cancelable event.
  2389.         event.cancelable = true;
  2391.         this.playerInterface_.onEvent(event);
  2393.         if (event.defaultPrevented) {
  2394.           // If the caller uses preventDefault() on the 'emsg' event, don't
  2395.           // process any further, and don't generate an ID3 'metadata' event
  2396.           // for the same data.
  2397.           return;
  2398.         }
  2400.         // Additionally, ID3 events generate a 'metadata' event.  This is a
  2401.         // pre-parsed version of the metadata blob already dispatched in the
  2402.         // 'emsg' event.
  2403.         if (schemeId == 'https://aomedia.org/emsg/ID3' ||
  2404.             schemeId == 'https://developer.apple.com/streaming/emsg-id3') {
  2405.           // See https://aomediacodec.github.io/id3-emsg/
  2406.           const frames = shaka.util.Id3Utils.getID3Frames(messageData);
  2407.           if (frames.length && reference) {
  2408.             /** @private {shaka.extern.ID3Metadata} */
  2409.             const metadata = {
  2410.               cueTime: reference.startTime,
  2411.               data: messageData,
  2412.               frames: frames,
  2413.               dts: reference.startTime,
  2414.               pts: reference.startTime,
  2415.             };
  2416.             this.playerInterface_.onMetadata(
  2417.                 [metadata], /* offset= */ 0, reference.endTime);
  2418.           }
  2419.         }
  2420.       }
  2421.     }
  2422.   }
  2424.   /**
  2425.    * Parse PRFT box.
  2426.    * @param {!shaka.media.SegmentReference} reference
  2427.    * @param {!shaka.extern.ParsedBox} box
  2428.    * @private
  2429.    */
  2430.   parsePrft_(reference, box) {
  2431.     if (this.parsedPrftEventRaised_ ||
  2432.       !reference.initSegmentReference.timescale) {
  2433.       return;
  2434.     }
  2435.     goog.asserts.assert(
  2436.         box.version == 0 || box.version == 1,
  2437.         'PRFT version can only be 0 or 1');
  2438.     const parsed = shaka.util.Mp4BoxParsers.parsePRFTInaccurate(
  2439.         box.reader, box.version);
  2441.     const timescale = reference.initSegmentReference.timescale;
  2442.     const wallClockTime = this.convertNtp(parsed.ntpTimestamp);
  2443.     const programStartDate = new Date(wallClockTime -
  2444.       (parsed.mediaTime / timescale) * 1000);
  2445.     const prftInfo = {
  2446.       wallClockTime,
  2447.       programStartDate,
  2448.     };
  2450.     const eventName = shaka.util.FakeEvent.EventName.Prft;
  2451.     const data = (new Map()).set('detail', prftInfo);
  2452.     const event = new shaka.util.FakeEvent(
  2453.         eventName, data);
  2454.     this.playerInterface_.onEvent(event);
  2455.     this.parsedPrftEventRaised_ = true;
  2456.   }
  2459.   /**
  2460.    * Convert Ntp ntpTimeStamp to UTC Time
  2461.    *
  2462.    * @param {number} ntpTimeStamp
  2463.    * @return {number} utcTime
  2464.    */
  2465.   convertNtp(ntpTimeStamp) {
  2466.     const start = new Date(Date.UTC(1900, 0, 1, 0, 0, 0));
  2467.     return new Date(start.getTime() + ntpTimeStamp).getTime();
  2468.   }
  2470.   /**
  2471.    * Evicts media to meet the max buffer behind limit.
  2472.    *
  2473.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  2474.    * @param {number} presentationTime
  2475.    * @private
  2476.    */
  2477.   async evict_(mediaState, presentationTime) {
  2478.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  2479.     shaka.log.v2(logPrefix, 'checking buffer length');
  2481.     // Use the max segment duration, if it is longer than the bufferBehind, to
  2482.     // avoid accidentally clearing too much data when dealing with a manifest
  2483.     // with a long keyframe interval.
  2484.     const bufferBehind = Math.max(this.config_.bufferBehind,
  2485.         this.manifest_.presentationTimeline.getMaxSegmentDuration());
  2487.     const startTime =
  2488.         this.playerInterface_.mediaSourceEngine.bufferStart(mediaState.type);
  2489.     if (startTime == null) {
  2490.       shaka.log.v2(logPrefix,
  2491.           'buffer behind okay because nothing buffered:',
  2492.           'presentationTime=' + presentationTime,
  2493.           'bufferBehind=' + bufferBehind);
  2494.       return;
  2495.     }
  2496.     const bufferedBehind = presentationTime - startTime;
  2498.     const overflow = bufferedBehind - bufferBehind;
  2499.     // See: https://github.com/shaka-project/shaka-player/issues/6240
  2500.     if (overflow <= this.config_.evictionGoal) {
  2501.       shaka.log.v2(logPrefix,
  2502.           'buffer behind okay:',
  2503.           'presentationTime=' + presentationTime,
  2504.           'bufferedBehind=' + bufferedBehind,
  2505.           'bufferBehind=' + bufferBehind,
  2506.           'evictionGoal=' + this.config_.evictionGoal,
  2507.           'underflow=' + Math.abs(overflow));
  2508.       return;
  2509.     }
  2511.     shaka.log.v1(logPrefix,
  2512.         'buffer behind too large:',
  2513.         'presentationTime=' + presentationTime,
  2514.         'bufferedBehind=' + bufferedBehind,
  2515.         'bufferBehind=' + bufferBehind,
  2516.         'evictionGoal=' + this.config_.evictionGoal,
  2517.         'overflow=' + overflow);
  2519.     await this.playerInterface_.mediaSourceEngine.remove(mediaState.type,
  2520.         startTime, startTime + overflow);
  2522.     this.destroyer_.ensureNotDestroyed();
  2523.     shaka.log.v1(logPrefix, 'evicted ' + overflow + ' seconds');
  2524.   }
  2527.   /**
  2528.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  2529.    * @return {boolean}
  2530.    * @private
  2531.    */
  2532.   static isEmbeddedText_(mediaState) {
  2533.     const MimeUtils = shaka.util.MimeUtils;
  2534.     const CEA608_MIME = MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE;
  2535.     const CEA708_MIME = MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE;
  2536.     return mediaState &&
  2537.         mediaState.type == shaka.util.ManifestParserUtils.ContentType.TEXT &&
  2538.         (mediaState.stream.mimeType == CEA608_MIME ||
  2539.          mediaState.stream.mimeType == CEA708_MIME);
  2540.   }
  2543.   /**
  2544.    * Fetches the given segment.
  2545.    *
  2546.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  2547.    * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
  2548.    *   reference
  2549.    * @param {?function(BufferSource):!Promise=} streamDataCallback
  2550.    *
  2551.    * @return {!Promise.<BufferSource>}
  2552.    * @private
  2553.    */
  2554.   async fetch_(mediaState, reference, streamDataCallback) {
  2555.     const segmentData = reference.getSegmentData();
  2556.     if (segmentData) {
  2557.       return segmentData;
  2558.     }
  2559.     let op = null;
  2560.     if (mediaState.segmentPrefetch) {
  2561.       op = mediaState.segmentPrefetch.getPrefetchedSegment(
  2562.           reference, streamDataCallback);
  2563.     }
  2564.     if (!op) {
  2565.       op = this.dispatchFetch_(
  2566.           reference, mediaState.stream, streamDataCallback);
  2567.     }
  2569.     let position = 0;
  2570.     if (mediaState.segmentIterator) {
  2571.       position = mediaState.segmentIterator.currentPosition();
  2572.     }
  2574.     mediaState.operation = op;
  2575.     const response = await op.promise;
  2576.     mediaState.operation = null;
  2577.     let result = response.data;
  2578.     if (reference.aesKey) {
  2579.       result = await this.aesDecrypt_(result, reference.aesKey, position);
  2580.     }
  2581.     return result;
  2582.   }
  2584.   /**
  2585.    * Fetches the given segment.
  2586.    *
  2587.    * @param {!shaka.extern.Stream} stream
  2588.    * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
  2589.    *   reference
  2590.    * @param {?function(BufferSource):!Promise=} streamDataCallback
  2591.    *
  2592.    * @return {!shaka.net.NetworkingEngine.PendingRequest}
  2593.    * @private
  2594.    */
  2595.   dispatchFetch_(reference, stream, streamDataCallback) {
  2596.     goog.asserts.assert(
  2597.         this.playerInterface_.netEngine, 'Must have net engine');
  2598.     return shaka.media.StreamingEngine.dispatchFetch(
  2599.         reference, stream, streamDataCallback || null,
  2600.         this.config_.retryParameters, this.playerInterface_.netEngine);
  2601.   }
  2603.   /**
  2604.    * Fetches the given segment.
  2605.    *
  2606.    * @param {!shaka.extern.Stream} stream
  2607.    * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
  2608.    *   reference
  2609.    * @param {?function(BufferSource):!Promise} streamDataCallback
  2610.    * @param {shaka.extern.RetryParameters} retryParameters
  2611.    * @param {!shaka.net.NetworkingEngine} netEngine
  2612.    *
  2613.    * @return {!shaka.net.NetworkingEngine.PendingRequest}
  2614.    */
  2615.   static dispatchFetch(
  2616.       reference, stream, streamDataCallback, retryParameters, netEngine) {
  2617.     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  2618.     const segment = reference instanceof shaka.media.SegmentReference ?
  2619.         reference : undefined;
  2620.     const type = segment ?
  2621.         shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT :
  2622.         shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
  2623.     const request = shaka.util.Networking.createSegmentRequest(
  2624.         reference.getUris(),
  2625.         reference.startByte,
  2626.         reference.endByte,
  2627.         retryParameters,
  2628.         streamDataCallback);
  2629.     request.contentType = stream.type;
  2631.     shaka.log.v2('fetching: reference=', reference);
  2633.     return netEngine.request(requestType, request, {type, stream, segment});
  2634.   }
  2636.   /**
  2637.    * Clears the buffer and schedules another update.
  2638.    * The optional parameter safeMargin allows to retain a certain amount
  2639.    * of buffer, which can help avoiding rebuffering events.
  2640.    * The value of the safe margin should be provided by the ABR manager.
  2641.    *
  2642.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  2643.    * @param {boolean} flush
  2644.    * @param {number} safeMargin
  2645.    * @private
  2646.    */
  2647.   async clearBuffer_(mediaState, flush, safeMargin) {
  2648.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  2650.     goog.asserts.assert(
  2651.         !mediaState.performingUpdate && (mediaState.updateTimer == null),
  2652.         logPrefix + ' unexpected call to clearBuffer_()');
  2654.     mediaState.waitingToClearBuffer = false;
  2655.     mediaState.waitingToFlushBuffer = false;
  2656.     mediaState.clearBufferSafeMargin = 0;
  2657.     mediaState.clearingBuffer = true;
  2658.     mediaState.lastSegmentReference = null;
  2659.     mediaState.segmentIterator = null;
  2661.     shaka.log.debug(logPrefix, 'clearing buffer');
  2662.     if (mediaState.segmentPrefetch &&
  2663.         !this.audioPrefetchMap_.has(mediaState.stream)) {
  2664.       mediaState.segmentPrefetch.clearAll();
  2665.     }
  2667.     if (safeMargin) {
  2668.       const presentationTime = this.playerInterface_.getPresentationTime();
  2669.       const duration = this.playerInterface_.mediaSourceEngine.getDuration();
  2670.       await this.playerInterface_.mediaSourceEngine.remove(
  2671.           mediaState.type, presentationTime + safeMargin, duration);
  2672.     } else {
  2673.       await this.playerInterface_.mediaSourceEngine.clear(mediaState.type);
  2674.       this.destroyer_.ensureNotDestroyed();
  2676.       if (flush) {
  2677.         await this.playerInterface_.mediaSourceEngine.flush(
  2678.             mediaState.type);
  2679.       }
  2680.     }
  2682.     this.destroyer_.ensureNotDestroyed();
  2684.     shaka.log.debug(logPrefix, 'cleared buffer');
  2685.     mediaState.clearingBuffer = false;
  2686.     mediaState.endOfStream = false;
  2687.     // Since the clear operation was async, check to make sure we're not doing
  2688.     // another update and we don't have one scheduled yet.
  2689.     if (!mediaState.performingUpdate && !mediaState.updateTimer) {
  2690.       this.scheduleUpdate_(mediaState, 0);
  2691.     }
  2692.   }
  2695.   /**
  2696.    * Schedules |mediaState|'s next update.
  2697.    *
  2698.    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
  2699.    * @param {number} delay The delay in seconds.
  2700.    * @private
  2701.    */
  2702.   scheduleUpdate_(mediaState, delay) {
  2703.     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
  2705.     // If the text's update is canceled and its mediaState is deleted, stop
  2706.     // scheduling another update.
  2707.     const type = mediaState.type;
  2708.     if (type == shaka.util.ManifestParserUtils.ContentType.TEXT &&
  2709.           !this.mediaStates_.has(type)) {
  2710.       shaka.log.v1(logPrefix, 'Text stream is unloaded. No update is needed.');
  2711.       return;
  2712.     }
  2714.     shaka.log.v2(logPrefix, 'updating in ' + delay + ' seconds');
  2715.     goog.asserts.assert(mediaState.updateTimer == null,
  2716.         logPrefix + ' did not expect update to be scheduled');
  2718.     mediaState.updateTimer = new shaka.util.DelayedTick(async () => {
  2719.       try {
  2720.         await this.onUpdate_(mediaState);
  2721.       } catch (error) {
  2722.         if (this.playerInterface_) {
  2723.           this.playerInterface_.onError(error);
  2724.         }
  2725.       }
  2726.     }).tickAfter(delay);
  2727.   }
  2730.   /**
  2731.    * If |mediaState| is scheduled to update, stop it.
  2732.    *
  2733.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  2734.    * @private
  2735.    */
  2736.   cancelUpdate_(mediaState) {
  2737.     if (mediaState.updateTimer == null) {
  2738.       return;
  2739.     }
  2741.     mediaState.updateTimer.stop();
  2742.     mediaState.updateTimer = null;
  2743.   }
  2746.   /**
  2747.    * If |mediaState| holds any in-progress operations, abort them.
  2748.    *
  2749.    * @return {!Promise}
  2750.    * @private
  2751.    */
  2752.   async abortOperations_(mediaState) {
  2753.     if (mediaState.operation) {
  2754.       await mediaState.operation.abort();
  2755.     }
  2756.   }
  2758.   /**
  2759.    * Handle streaming errors by delaying, then notifying the application by
  2760.    * error callback and by streaming failure callback.
  2761.    *
  2762.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  2763.    * @param {!shaka.util.Error} error
  2764.    * @return {!Promise}
  2765.    * @private
  2766.    */
  2767.   async handleStreamingError_(mediaState, error) {
  2768.     // If we invoke the callback right away, the application could trigger a
  2769.     // rapid retry cycle that could be very unkind to the server.  Instead,
  2770.     // use the backoff system to delay and backoff the error handling.
  2771.     await this.failureCallbackBackoff_.attempt();
  2772.     this.destroyer_.ensureNotDestroyed();
  2774.     const maxDisabledTime = this.getDisabledTime_(error);
  2775.     // Try to recover from network errors
  2776.     if (error.category === shaka.util.Error.Category.NETWORK &&
  2777.         maxDisabledTime > 0) {
  2778.       error.handled = this.playerInterface_.disableStream(
  2779.           mediaState.stream, maxDisabledTime);
  2781.       // Decrease the error severity to recoverable
  2782.       if (error.handled) {
  2783.         error.severity = shaka.util.Error.Severity.RECOVERABLE;
  2784.       }
  2785.     }
  2787.     // First fire an error event.
  2788.     if (!error.handled ||
  2789.         error.code != shaka.util.Error.Code.SEGMENT_MISSING) {
  2790.       this.playerInterface_.onError(error);
  2791.     }
  2793.     // If the error was not handled by the application, call the failure
  2794.     // callback.
  2795.     if (!error.handled) {
  2796.       this.config_.failureCallback(error);
  2797.     }
  2798.   }
  2800.   /**
  2801.    * @param {!shaka.util.Error} error
  2802.    * @private
  2803.    */
  2804.   getDisabledTime_(error) {
  2805.     if (this.config_.maxDisabledTime === 0 &&
  2806.         error.code == shaka.util.Error.Code.SEGMENT_MISSING) {
  2807.       // Spec: https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis#section-6.3.3
  2808.       // The client SHOULD NOT attempt to load Media Segments that have been
  2809.       // marked with an EXT-X-GAP tag, or to load Partial Segments with a
  2810.       // GAP=YES attribute. Instead, clients are encouraged to look for
  2811.       // another Variant Stream of the same Rendition which does not have the
  2812.       // same gap, and play that instead.
  2813.       return 1;
  2814.     }
  2816.     return this.config_.maxDisabledTime;
  2817.   }
  2819.   /**
  2820.    * Reset Media Source
  2821.    *
  2822.    * @return {!Promise.<boolean>}
  2823.    */
  2824.   async resetMediaSource() {
  2825.     const now = (Date.now() / 1000);
  2826.     const minTimeBetweenRecoveries = this.config_.minTimeBetweenRecoveries;
  2827.     if (!this.config_.allowMediaSourceRecoveries ||
  2828.         (now - this.lastMediaSourceReset_) < minTimeBetweenRecoveries) {
  2829.       return false;
  2830.     }
  2831.     this.lastMediaSourceReset_ = now;
  2832.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2833.     const audioMediaState = this.mediaStates_.get(ContentType.AUDIO);
  2834.     if (audioMediaState) {
  2835.       audioMediaState.lastInitSegmentReference = null;
  2836.       this.forceClearBuffer_(audioMediaState);
  2837.       this.abortOperations_(audioMediaState).catch(() => {});
  2838.     }
  2839.     const videoMediaState = this.mediaStates_.get(ContentType.VIDEO);
  2840.     if (videoMediaState) {
  2841.       videoMediaState.lastInitSegmentReference = null;
  2842.       this.forceClearBuffer_(videoMediaState);
  2843.       this.abortOperations_(videoMediaState).catch(() => {});
  2844.     }
  2845.     /**
  2846.      * @type {!Map.<shaka.util.ManifestParserUtils.ContentType,
  2847.      *              shaka.extern.Stream>}
  2848.      */
  2849.     const streamsByType = new Map();
  2850.     if (this.currentVariant_.audio) {
  2851.       streamsByType.set(ContentType.AUDIO, this.currentVariant_.audio);
  2852.     }
  2853.     if (this.currentVariant_.video) {
  2854.       streamsByType.set(ContentType.VIDEO, this.currentVariant_.video);
  2855.     }
  2856.     await this.playerInterface_.mediaSourceEngine.reset(streamsByType);
  2857.     return true;
  2858.   }
  2860.   /**
  2861.    * Update the spatial video info and notify to the app.
  2862.    *
  2863.    * @param {shaka.extern.SpatialVideoInfo} info
  2864.    * @private
  2865.    */
  2866.   updateSpatialVideoInfo_(info) {
  2867.     if (this.spatialVideoInfo_.projection != info.projection ||
  2868.         this.spatialVideoInfo_.hfov != info.hfov) {
  2869.       const EventName = shaka.util.FakeEvent.EventName;
  2870.       let event;
  2871.       if (info.projection != null || info.hfov != null) {
  2872.         const eventName = EventName.SpatialVideoInfoEvent;
  2873.         const data = (new Map()).set('detail', info);
  2874.         event = new shaka.util.FakeEvent(eventName, data);
  2875.       } else {
  2876.         const eventName = EventName.NoSpatialVideoInfoEvent;
  2877.         event = new shaka.util.FakeEvent(eventName);
  2878.       }
  2879.       event.cancelable = true;
  2880.       this.playerInterface_.onEvent(event);
  2881.       this.spatialVideoInfo_ = info;
  2882.     }
  2883.   }
  2885.   /**
  2886.    * Update the segment iterator direction.
  2887.    *
  2888.    * @private
  2889.    */
  2890.   updateSegmentIteratorReverse_() {
  2891.     const reverse = this.playerInterface_.getPlaybackRate() < 0;
  2892.     for (const mediaState of this.mediaStates_.values()) {
  2893.       if (mediaState.segmentIterator) {
  2894.         mediaState.segmentIterator.setReverse(reverse);
  2895.       }
  2896.       if (mediaState.segmentPrefetch) {
  2897.         mediaState.segmentPrefetch.setReverse(reverse);
  2898.       }
  2899.     }
  2900.     for (const prefetch of this.audioPrefetchMap_.values()) {
  2901.       prefetch.setReverse(reverse);
  2902.     }
  2903.   }
  2905.   /**
  2906.    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
  2907.    * @return {string} A log prefix of the form ($CONTENT_TYPE:$STREAM_ID), e.g.,
  2908.    *   "(audio:5)" or "(video:hd)".
  2909.    * @private
  2910.    */
  2911.   static logPrefix_(mediaState) {
  2912.     return '(' + mediaState.type + ':' + mediaState.stream.id + ')';
  2913.   }
  2914. };
  2917. /**
  2918.  * @typedef {{
  2919.  *   getPresentationTime: function():number,
  2920.  *   getBandwidthEstimate: function():number,
  2921.  *   getPlaybackRate: function():number,
  2922.  *   mediaSourceEngine: !shaka.media.MediaSourceEngine,
  2923.  *   netEngine: shaka.net.NetworkingEngine,
  2924.  *   onError: function(!shaka.util.Error),
  2925.  *   onEvent: function(!Event),
  2926.  *   onManifestUpdate: function(),
  2927.  *   onSegmentAppended: function(!shaka.media.SegmentReference,
  2928.  *     !shaka.extern.Stream),
  2929.  *   onInitSegmentAppended: function(!number,!shaka.media.InitSegmentReference),
  2930.  *   beforeAppendSegment: function(
  2931.  *     shaka.util.ManifestParserUtils.ContentType,!BufferSource):Promise,
  2932.  *   onMetadata: !function(!Array.<shaka.extern.ID3Metadata>, number, ?number),
  2933.  *   disableStream: function(!shaka.extern.Stream, number):boolean
  2934.  * }}
  2935.  *
  2936.  * @property {function():number} getPresentationTime
  2937.  *   Get the position in the presentation (in seconds) of the content that the
  2938.  *   viewer is seeing on screen right now.
  2939.  * @property {function():number} getBandwidthEstimate
  2940.  *   Get the estimated bandwidth in bits per second.
  2941.  * @property {function():number} getPlaybackRate
  2942.  *   Get the playback rate
  2943.  * @property {!shaka.media.MediaSourceEngine} mediaSourceEngine
  2944.  *   The MediaSourceEngine. The caller retains ownership.
  2945.  * @property {shaka.net.NetworkingEngine} netEngine
  2946.  *   The NetworkingEngine instance to use. The caller retains ownership.
  2947.  * @property {function(!shaka.util.Error)} onError
  2948.  *   Called when an error occurs. If the error is recoverable (see
  2949.  *   {@link shaka.util.Error}) then the caller may invoke either
  2950.  *   StreamingEngine.switch*() or StreamingEngine.seeked() to attempt recovery.
  2951.  * @property {function(!Event)} onEvent
  2952.  *   Called when an event occurs that should be sent to the app.
  2953.  * @property {function()} onManifestUpdate
  2954.  *   Called when an embedded 'emsg' box should trigger a manifest update.
  2955.  * @property {function(!shaka.media.SegmentReference,
  2956.  *     !shaka.extern.Stream)} onSegmentAppended
  2957.  *   Called after a segment is successfully appended to a MediaSource.
  2958.  * @property
  2959.  *  {function(!number, !shaka.media.InitSegmentReference)} onInitSegmentAppended
  2960.  *   Called when an init segment is appended to a MediaSource.
  2961.  * @property {!function(shaka.util.ManifestParserUtils.ContentType,
  2962.  *   !BufferSource):Promise} beforeAppendSegment
  2963.  *   A function called just before appending to the source buffer.
  2964.  * @property
  2965.  *  {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)} onMetadata
  2966.  *   Called when an ID3 is found in a EMSG.
  2967.  * @property {function(!shaka.extern.Stream, number):boolean} disableStream
  2968.  *   Called to temporarily disable a stream i.e. disabling all variant
  2969.  *   containing said stream.
  2970.  */
  2971. shaka.media.StreamingEngine.PlayerInterface;
  2974. /**
  2975.  * @typedef {{
  2976.  *   type: shaka.util.ManifestParserUtils.ContentType,
  2977.  *   stream: shaka.extern.Stream,
  2978.  *   segmentIterator: shaka.media.SegmentIterator,
  2979.  *   lastSegmentReference: shaka.media.SegmentReference,
  2980.  *   lastInitSegmentReference: shaka.media.InitSegmentReference,
  2981.  *   lastTimestampOffset: ?number,
  2982.  *   lastAppendWindowStart: ?number,
  2983.  *   lastAppendWindowEnd: ?number,
  2984.  *   lastCodecs: ?string,
  2985.  *   lastMimeType: ?string,
  2986.  *   restoreStreamAfterTrickPlay: ?shaka.extern.Stream,
  2987.  *   endOfStream: boolean,
  2988.  *   performingUpdate: boolean,
  2989.  *   updateTimer: shaka.util.DelayedTick,
  2990.  *   waitingToClearBuffer: boolean,
  2991.  *   waitingToFlushBuffer: boolean,
  2992.  *   clearBufferSafeMargin: number,
  2993.  *   clearingBuffer: boolean,
  2994.  *   seeked: boolean,
  2995.  *   adaptation: boolean,
  2996.  *   recovering: boolean,
  2997.  *   hasError: boolean,
  2998.  *   operation: shaka.net.NetworkingEngine.PendingRequest,
  2999.  *   segmentPrefetch: shaka.media.SegmentPrefetch
  3000.  * }}
  3001.  *
  3002.  * @description
  3003.  * Contains the state of a logical stream, i.e., a sequence of segmented data
  3004.  * for a particular content type. At any given time there is a Stream object
  3005.  * associated with the state of the logical stream.
  3006.  *
  3007.  * @property {shaka.util.ManifestParserUtils.ContentType} type
  3008.  *   The stream's content type, e.g., 'audio', 'video', or 'text'.
  3009.  * @property {shaka.extern.Stream} stream
  3010.  *   The current Stream.
  3011.  * @property {shaka.media.SegmentIndexIterator} segmentIterator
  3012.  *   An iterator through the segments of |stream|.
  3013.  * @property {shaka.media.SegmentReference} lastSegmentReference
  3014.  *   The SegmentReference of the last segment that was appended.
  3015.  * @property {shaka.media.InitSegmentReference} lastInitSegmentReference
  3016.  *   The InitSegmentReference of the last init segment that was appended.
  3017.  * @property {?number} lastTimestampOffset
  3018.  *   The last timestamp offset given to MediaSourceEngine for this type.
  3019.  * @property {?number} lastAppendWindowStart
  3020.  *   The last append window start given to MediaSourceEngine for this type.
  3021.  * @property {?number} lastAppendWindowEnd
  3022.  *   The last append window end given to MediaSourceEngine for this type.
  3023.  * @property {?string} lastCodecs
  3024.  *   The last append codecs given to MediaSourceEngine for this type.
  3025.  * @property {?string} lastMimeType
  3026.  *   The last append mime type given to MediaSourceEngine for this type.
  3027.  * @property {?shaka.extern.Stream} restoreStreamAfterTrickPlay
  3028.  *   The Stream to restore after trick play mode is turned off.
  3029.  * @property {boolean} endOfStream
  3030.  *   True indicates that the end of the buffer has hit the end of the
  3031.  *   presentation.
  3032.  * @property {boolean} performingUpdate
  3033.  *   True indicates that an update is in progress.
  3034.  * @property {shaka.util.DelayedTick} updateTimer
  3035.  *   A timer used to update the media state.
  3036.  * @property {boolean} waitingToClearBuffer
  3037.  *   True indicates that the buffer must be cleared after the current update
  3038.  *   finishes.
  3039.  * @property {boolean} waitingToFlushBuffer
  3040.  *   True indicates that the buffer must be flushed after it is cleared.
  3041.  * @property {number} clearBufferSafeMargin
  3042.  *   The amount of buffer to retain when clearing the buffer after the update.
  3043.  * @property {boolean} clearingBuffer
  3044.  *   True indicates that the buffer is being cleared.
  3045.  * @property {boolean} seeked
  3046.  *   True indicates that the presentation just seeked.
  3047.  * @property {boolean} adaptation
  3048.  *   True indicates that the presentation just automatically switched variants.
  3049.  * @property {boolean} recovering
  3050.  *   True indicates that the last segment was not appended because it could not
  3051.  *   fit in the buffer.
  3052.  * @property {boolean} hasError
  3053.  *   True indicates that the stream has encountered an error and has stopped
  3054.  *   updating.
  3055.  * @property {shaka.net.NetworkingEngine.PendingRequest} operation
  3056.  *   Operation with the number of bytes to be downloaded.
  3057.  * @property {?shaka.media.SegmentPrefetch} segmentPrefetch
  3058.  *   A prefetch object for managing prefetching. Null if unneeded
  3059.  *   (if prefetching is disabled, etc).
  3060.  */
  3061. shaka.media.StreamingEngine.MediaState_;
  3064. /**
  3065.  * The fudge factor for appendWindowStart.  By adjusting the window backward, we
  3066.  * avoid rounding errors that could cause us to remove the keyframe at the start
  3067.  * of the Period.
  3068.  *
  3069.  * NOTE: This was increased as part of the solution to
  3070.  * https://github.com/shaka-project/shaka-player/issues/1281
  3071.  *
  3072.  * @const {number}
  3073.  * @private
  3074.  */
  3075. shaka.media.StreamingEngine.APPEND_WINDOW_START_FUDGE_ = 0.1;
  3078. /**
  3079.  * The fudge factor for appendWindowEnd.  By adjusting the window backward, we
  3080.  * avoid rounding errors that could cause us to remove the last few samples of
  3081.  * the Period.  This rounding error could then create an artificial gap and a
  3082.  * stutter when the gap-jumping logic takes over.
  3083.  *
  3084.  * https://github.com/shaka-project/shaka-player/issues/1597
  3085.  *
  3086.  * @const {number}
  3087.  * @private
  3088.  */
  3089. shaka.media.StreamingEngine.APPEND_WINDOW_END_FUDGE_ = 0.01;
  3092. /**
  3093.  * The maximum number of segments by which a stream can get ahead of other
  3094.  * streams.
  3095.  *
  3096.  * Introduced to keep StreamingEngine from letting one media type get too far
  3097.  * ahead of another.  For example, audio segments are typically much smaller
  3098.  * than video segments, so in the time it takes to fetch one video segment, we
  3099.  * could fetch many audio segments.  This doesn't help with buffering, though,
  3100.  * since the intersection of the two buffered ranges is what counts.
  3101.  *
  3102.  * @const {number}
  3103.  * @private
  3104.  */
  3105. shaka.media.StreamingEngine.MAX_RUN_AHEAD_SEGMENTS_ = 1;