Source: lib/media/preload_manager.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2023 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.PreloadManager');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.Error');
  12. goog.require('shaka.media.ManifestFilterer');
  13. goog.require('shaka.media.ManifestParser');
  14. goog.require('shaka.util.PublicPromise');
  15. goog.require('shaka.media.PreferenceBasedCriteria');
  16. goog.require('shaka.util.Stats');
  17. goog.require('shaka.media.SegmentPrefetch');
  18. goog.require('shaka.util.IDestroyable');
  19. goog.require('shaka.net.NetworkingEngine');
  20. goog.require('shaka.media.AdaptationSetCriteria');
  21. goog.require('shaka.media.DrmEngine');
  22. goog.require('shaka.media.RegionTimeline');
  23. goog.require('shaka.media.QualityObserver');
  24. goog.require('shaka.util.StreamUtils');
  25. goog.require('shaka.media.StreamingEngine');
  26. goog.require('shaka.media.SegmentPrefetch');
  27. goog.require('shaka.util.ConfigUtils');
  28. goog.require('shaka.util.FakeEvent');
  29. goog.require('shaka.util.FakeEventTarget');
  30. goog.require('shaka.util.ObjectUtils');
  31. goog.require('shaka.util.Platform');
  32. goog.require('shaka.util.PlayerConfiguration');
  34. /**
  35.  * @implements {shaka.util.IDestroyable}
  36.  * @export
  37.  */
  38. shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
  39.   /**
  40.    * @param {string} assetUri
  41.    * @param {?string} mimeType
  42.    * @param {?number} startTime
  43.    * @param {*} playerInterface
  44.    */
  45.   constructor(assetUri, mimeType, startTime, playerInterface) {
  46.     super();
  48.     // Making the playerInterface a * and casting it to the right type allows
  49.     // for the PlayerInterface for this class to not be exported.
  50.     // Unfortunately, the constructor is exported by default.
  51.     const typedPlayerInterface =
  52.     /** @type {!shaka.media.PreloadManager.PlayerInterface} */ (
  53.         playerInterface);
  55.     /** @private {string} */
  56.     this.assetUri_ = assetUri;
  58.     /** @private {?string} */
  59.     this.mimeType_ = mimeType;
  61.     /** @private {!shaka.net.NetworkingEngine} */
  62.     this.networkingEngine_ = typedPlayerInterface.networkingEngine;
  64.     /** @private {?number} */
  65.     this.startTime_ = startTime;
  67.     /** @private {?shaka.media.AdaptationSetCriteria} */
  68.     this.currentAdaptationSetCriteria_ = null;
  70.     /** @private {number} */
  71.     this.startTimeOfDrm_ = 0;
  73.     /** @private {function():!shaka.media.DrmEngine} */
  74.     this.createDrmEngine_ = typedPlayerInterface.createDrmEngine;
  76.     /** @private {!shaka.media.ManifestFilterer} */
  77.     this.manifestFilterer_ = typedPlayerInterface.manifestFilterer;
  79.     /** @private {!shaka.extern.ManifestParser.PlayerInterface} */
  80.     this.manifestPlayerInterface_ =
  81.         typedPlayerInterface.manifestPlayerInterface;
  83.     /** @private {!shaka.extern.PlayerConfiguration} */
  84.     this.config_ = typedPlayerInterface.config;
  86.     /** @private {?shaka.extern.Manifest} */
  87.     this.manifest_ = null;
  89.     /** @private {?shaka.extern.ManifestParser.Factory} */
  90.     this.parserFactory_ = null;
  92.     /** @private {?shaka.extern.ManifestParser} */
  93.     this.parser_ = null;
  95.     /** @private {boolean} */
  96.     this.parserEntrusted_ = false;
  98.     /** @private {!shaka.media.RegionTimeline} */
  99.     this.regionTimeline_ = typedPlayerInterface.regionTimeline;
  101.     /** @private {boolean} */
  102.     this.regionTimelineEntrusted_ = false;
  104.     /** @private {?shaka.media.DrmEngine} */
  105.     this.drmEngine_ = null;
  107.     /** @private {boolean} */
  108.     this.drmEngineEntrusted_ = false;
  110.     /** @private {?shaka.extern.AbrManager.Factory} */
  111.     this.abrManagerFactory_ = null;
  113.     /** @private {shaka.extern.AbrManager} */
  114.     this.abrManager_ = null;
  116.     /** @private {boolean} */
  117.     this.abrManagerEntrusted_ = false;
  119.     /** @private {!Map.<number, shaka.media.SegmentPrefetch>} */
  120.     this.segmentPrefetchById_ = new Map();
  122.     /** @private {boolean} */
  123.     this.segmentPrefetchEntrusted_ = false;
  125.     /** @private {?shaka.media.QualityObserver} */
  126.     this.qualityObserver_ = typedPlayerInterface.qualityObserver;
  128.     /** @private {!shaka.util.Stats} */
  129.     this.stats_ = new shaka.util.Stats();
  131.     /** @private {!shaka.util.PublicPromise} */
  132.     this.manifestPromise_ = new shaka.util.PublicPromise();
  134.     /** @private {!shaka.util.PublicPromise} */
  135.     this.successPromise_ = new shaka.util.PublicPromise();
  137.     /** @private {?shaka.util.FakeEventTarget} */
  138.     this.eventHandoffTarget_ = null;
  140.     /** @private {boolean} */
  141.     this.destroyed_ = false;
  143.     /** @private {boolean} */
  144.     this.allowPrefetch_ = typedPlayerInterface.allowPrefetch;
  146.     /** @private {?shaka.extern.Variant} */
  147.     this.prefetchedVariant_ = null;
  149.     /** @private {boolean} */
  150.     this.allowMakeAbrManager_ = typedPlayerInterface.allowMakeAbrManager;
  152.     /** @private {boolean} */
  153.     this.hasBeenAttached_ = false;
  155.     /** @private {?Array.<function()>} */
  156.     this.queuedOperations_ = [];
  158.     /** @private {?Array.<function()>} */
  159.     this.latePhaseQueuedOperations_ = [];
  161.     /** @private {boolean} */
  162.     this.isPreload_ = true;
  163.   }
  165.   /**
  166.    * Makes it so that net requests launched from this load will no longer be
  167.    * marked as "isPreload"
  168.    */
  169.   markIsLoad() {
  170.     this.isPreload_ = false;
  171.   }
  173.   /**
  174.    * @param {boolean} latePhase
  175.    * @param {function()} callback
  176.    */
  177.   addQueuedOperation(latePhase, callback) {
  178.     const queue =
  179.         latePhase ? this.latePhaseQueuedOperations_ : this.queuedOperations_;
  180.     if (queue) {
  181.       queue.push(callback);
  182.     } else {
  183.       callback();
  184.     }
  185.   }
  187.   /** Calls all late phase queued operations, and stops queueing them. */
  188.   stopQueuingLatePhaseQueuedOperations() {
  189.     if (this.latePhaseQueuedOperations_) {
  190.       for (const callback of this.latePhaseQueuedOperations_) {
  191.         callback();
  192.       }
  193.     }
  194.     this.latePhaseQueuedOperations_ = null;
  195.   }
  197.   /** @param {!shaka.util.FakeEventTarget} eventHandoffTarget */
  198.   setEventHandoffTarget(eventHandoffTarget) {
  199.     this.eventHandoffTarget_ = eventHandoffTarget;
  200.     this.hasBeenAttached_ = true;
  201.     // Also call all queued operations, and stop queuing them in the future.
  202.     if (this.queuedOperations_) {
  203.       for (const callback of this.queuedOperations_) {
  204.         callback();
  205.       }
  206.     }
  207.     this.queuedOperations_ = null;
  208.   }
  210.   /** @param {number} offset */
  211.   setOffsetToStartTime(offset) {
  212.     if (this.startTime_ && offset) {
  213.       this.startTime_ += offset;
  214.     }
  215.   }
  217.   /** @return {?number} */
  218.   getStartTime() {
  219.     return this.startTime_;
  220.   }
  222.   /** @return {number} */
  223.   getStartTimeOfDRM() {
  224.     return this.startTimeOfDrm_;
  225.   }
  227.   /** @return {?string} */
  228.   getMimeType() {
  229.     return this.mimeType_;
  230.   }
  232.   /** @return {string} */
  233.   getAssetUri() {
  234.     return this.assetUri_;
  235.   }
  237.   /** @return {?shaka.extern.Manifest} */
  238.   getManifest() {
  239.     return this.manifest_;
  240.   }
  242.   /** @return {?shaka.extern.ManifestParser.Factory} */
  243.   getParserFactory() {
  244.     return this.parserFactory_;
  245.   }
  247.   /** @return {?shaka.media.AdaptationSetCriteria} */
  248.   getCurrentAdaptationSetCriteria() {
  249.     return this.currentAdaptationSetCriteria_;
  250.   }
  252.   /** @return {?shaka.extern.AbrManager.Factory} */
  253.   getAbrManagerFactory() {
  254.     return this.abrManagerFactory_;
  255.   }
  257.   /**
  258.    * Gets the abr manager, if it exists. Also marks that the abr manager should
  259.    * not be stopped if this manager is destroyed.
  260.    * @return {?shaka.extern.AbrManager}
  261.    */
  262.   receiveAbrManager() {
  263.     this.abrManagerEntrusted_ = true;
  264.     return this.abrManager_;
  265.   }
  267.   /**
  268.    * @return {?shaka.extern.AbrManager}
  269.    */
  270.   getAbrManager() {
  271.     return this.abrManager_;
  272.   }
  274.   /**
  275.    * Gets the parser, if it exists. Also marks that the parser should not be
  276.    * stopped if this manager is destroyed.
  277.    * @return {?shaka.extern.ManifestParser}
  278.    */
  279.   receiveParser() {
  280.     this.parserEntrusted_ = true;
  281.     return this.parser_;
  282.   }
  284.   /**
  285.    * @return {?shaka.extern.ManifestParser}
  286.    */
  287.   getParser() {
  288.     return this.parser_;
  289.   }
  291.   /**
  292.    * Gets the region timeline, if it exists. Also marks that the timeline should
  293.    * not be released if this manager is destroyed.
  294.    * @return {?shaka.media.RegionTimeline}
  295.    */
  296.   receiveRegionTimeline() {
  297.     this.regionTimelineEntrusted_ = true;
  298.     return this.regionTimeline_;
  299.   }
  301.   /**
  302.    * @return {?shaka.media.RegionTimeline}
  303.    */
  304.   getRegionTimeline() {
  305.     return this.regionTimeline_;
  306.   }
  308.   /** @return {?shaka.media.QualityObserver} */
  309.   getQualityObserver() {
  310.     return this.qualityObserver_;
  311.   }
  313.   /** @return {!shaka.util.Stats} */
  314.   getStats() {
  315.     return this.stats_;
  316.   }
  318.   /** @return {!shaka.media.ManifestFilterer} */
  319.   getManifestFilterer() {
  320.     return this.manifestFilterer_;
  321.   }
  323.   /**
  324.    * Gets the drm engine, if it exists. Also marks that the drm engine should
  325.    * not be destroyed if this manager is destroyed.
  326.    * @return {?shaka.media.DrmEngine}
  327.    */
  328.   receiveDrmEngine() {
  329.     this.drmEngineEntrusted_ = true;
  330.     return this.drmEngine_;
  331.   }
  333.   /**
  334.    * @return {?shaka.media.DrmEngine}
  335.    */
  336.   getDrmEngine() {
  337.     return this.drmEngine_;
  338.   }
  340.   /**
  341.    * @return {?shaka.extern.Variant}
  342.    */
  343.   getPrefetchedVariant() {
  344.     return this.prefetchedVariant_;
  345.   }
  347.   /**
  348.    * Gets the SegmentPrefetch objects for the initial stream ids. Also marks
  349.    * that those objects should not be aborted if this manager is destroyed.
  350.    * @return {!Map.<number, shaka.media.SegmentPrefetch>}
  351.    */
  352.   receiveSegmentPrefetchesById() {
  353.     this.segmentPrefetchEntrusted_ = true;
  354.     return this.segmentPrefetchById_;
  355.   }
  357.   /**
  358.    * @param {?shaka.extern.AbrManager} abrManager
  359.    * @param {?shaka.extern.AbrManager.Factory} abrFactory
  360.    */
  361.   attachAbrManager(abrManager, abrFactory) {
  362.     this.abrManager_ = abrManager;
  363.     this.abrManagerFactory_ = abrFactory;
  364.   }
  366.   /**
  367.    * @param {?shaka.media.AdaptationSetCriteria} adaptationSetCriteria
  368.    */
  369.   attachAdaptationSetCriteria(adaptationSetCriteria) {
  370.     this.currentAdaptationSetCriteria_ = adaptationSetCriteria;
  371.   }
  373.   /**
  374.    * @param {!shaka.extern.Manifest} manifest
  375.    * @param {!shaka.extern.ManifestParser} parser
  376.    * @param {!shaka.extern.ManifestParser.Factory} parserFactory
  377.    */
  378.   attachManifest(manifest, parser, parserFactory) {
  379.     this.manifest_ = manifest;
  380.     this.parser_ = parser;
  381.     this.parserFactory_ = parserFactory;
  382.   }
  384.   /**
  385.    * Starts the process of loading the asset.
  386.    * Success or failure will be measured through waitForFinish()
  387.    */
  388.   start() {
  389.     (async () => {
  390.       // Force a context switch, to give the player a chance to hook up events
  391.       // immediately if desired.
  392.       await Promise.resolve();
  394.       // Perform the preloading process.
  395.       try {
  396.         await this.parseManifestInner_();
  397.         this.throwIfDestroyed_();
  399.         if (!shaka.util.Platform.isMediaKeysPolyfilled('webkit')) {
  400.           await this.initializeDrm();
  401.           this.throwIfDestroyed_();
  402.         }
  404.         await this.chooseInitialVariantAndPrefetchInner_();
  405.         this.throwIfDestroyed_();
  407.         // We don't need the drm keys to load completely for the initial variant
  408.         // to be chosen, but we won't mark the load as a success until it has
  409.         // been loaded. So wait for it here, not inside initializeDrmInner_.
  410.         if (this.drmEngine_) {
  411.           await this.drmEngine_.waitForActiveRequests();
  412.           this.throwIfDestroyed_();
  413.         }
  415.         this.successPromise_.resolve();
  416.       } catch (error) {
  417.         // Ignore OPERATION_ABORTED and OBJECT_DESTROYED errors.
  418.         if (!(error instanceof shaka.util.Error) ||
  419.             (error.code != shaka.util.Error.Code.OPERATION_ABORTED &&
  420.              error.code != shaka.util.Error.Code.OBJECT_DESTROYED)) {
  421.           this.successPromise_.reject(error);
  422.         }
  423.       }
  424.     })();
  425.   }
  427.   /**
  428.    * @param {!Event} event
  429.    * @return {boolean}
  430.    * @override
  431.    */
  432.   dispatchEvent(event) {
  433.     if (this.eventHandoffTarget_) {
  434.       return this.eventHandoffTarget_.dispatchEvent(event);
  435.     } else {
  436.       return super.dispatchEvent(event);
  437.     }
  438.   }
  440.   /**
  441.    * @param {!shaka.util.Error} error
  442.    */
  443.   onError(error) {
  444.     if (error.severity === shaka.util.Error.Severity.CRITICAL) {
  445.       // Cancel the loading process.
  446.       this.successPromise_.reject(error);
  447.       this.destroy();
  448.     }
  450.     const eventName = shaka.util.FakeEvent.EventName.Error;
  451.     const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
  452.     this.dispatchEvent(event);
  453.     if (event.defaultPrevented) {
  454.       error.handled = true;
  455.     }
  456.   }
  458.   /**
  459.    * Throw if destroyed, to interrupt processes with a recognizable error.
  460.    *
  461.    * @private
  462.    */
  463.   throwIfDestroyed_() {
  464.     if (this.isDestroyed()) {
  465.       throw new shaka.util.Error(
  466.           shaka.util.Error.Severity.CRITICAL,
  467.           shaka.util.Error.Category.PLAYER,
  468.           shaka.util.Error.Code.OBJECT_DESTROYED);
  469.     }
  470.   }
  472.   /**
  473.    * Makes a fires an event corresponding to entering a state of the loading
  474.    * process.
  475.    * @param {string} nodeName
  476.    * @private
  477.    */
  478.   makeStateChangeEvent_(nodeName) {
  479.     this.dispatchEvent(new shaka.util.FakeEvent(
  480.         /* name= */ shaka.util.FakeEvent.EventName.OnStateChange,
  481.         /* data= */ (new Map()).set('state', nodeName)));
  482.   }
  484.   /**
  485.    * @param {!shaka.util.FakeEvent.EventName} name
  486.    * @param {Map.<string, Object>=} data
  487.    * @return {!shaka.util.FakeEvent}
  488.    * @private
  489.    */
  490.   makeEvent_(name, data) {
  491.     return new shaka.util.FakeEvent(name, data);
  492.   }
  494.   /**
  495.    * Pick and initialize a manifest parser, then have it download and parse the
  496.    * manifest.
  497.    *
  498.    * @return {!Promise}
  499.    * @private
  500.    */
  501.   async parseManifestInner_() {
  502.     this.makeStateChangeEvent_('manifest-parser');
  504.     if (!this.parser_) {
  505.       // Create the parser that we will use to parse the manifest.
  506.       this.parserFactory_ = shaka.media.ManifestParser.getFactory(
  507.           this.assetUri_, this.mimeType_);
  508.       goog.asserts.assert(this.parserFactory_, 'Must have manifest parser');
  509.       this.parser_ = this.parserFactory_();
  511.       this.parser_.configure(this.config_.manifest, () => this.isPreload_);
  512.     }
  514.     const startTime = Date.now() / 1000;
  516.     this.makeStateChangeEvent_('manifest');
  518.     if (!this.manifest_) {
  519.       this.manifest_ = await this.parser_.start(
  520.           this.assetUri_, this.manifestPlayerInterface_);
  521.     }
  523.     this.manifestPromise_.resolve();
  525.     // This event is fired after the manifest is parsed, but before any
  526.     // filtering takes place.
  527.     const event =
  528.           this.makeEvent_(shaka.util.FakeEvent.EventName.ManifestParsed);
  529.     // Delay event to ensure manifest has been properly propagated
  530.     // to the player.
  531.     await Promise.resolve();
  532.     this.dispatchEvent(event);
  534.     // We require all manifests to have at least one variant.
  535.     if (this.manifest_.variants.length == 0) {
  536.       throw new shaka.util.Error(
  537.           shaka.util.Error.Severity.CRITICAL,
  538.           shaka.util.Error.Category.MANIFEST,
  539.           shaka.util.Error.Code.NO_VARIANTS);
  540.     }
  542.     // Make sure that all variants are either: audio-only, video-only, or
  543.     // audio-video.
  544.     shaka.media.PreloadManager.filterForAVVariants_(this.manifest_);
  546.     const now = Date.now() / 1000;
  547.     const delta = now - startTime;
  548.     this.stats_.setManifestTime(delta);
  549.   }
  551.   /**
  552.    * Initializes the DRM engine.
  553.    * @param {?HTMLMediaElement=} media
  554.    * @return {!Promise}
  555.    */
  556.   async initializeDrm(media) {
  557.     if (!this.manifest_ || this.drmEngine_) {
  558.       return;
  559.     }
  561.     this.makeStateChangeEvent_('drm-engine');
  563.     this.startTimeOfDrm_ = Date.now() / 1000;
  565.     this.drmEngine_ = this.createDrmEngine_();
  566.     this.manifestFilterer_.setDrmEngine(this.drmEngine_);
  568.     this.drmEngine_.configure(this.config_.drm, () => this.isPreload_);
  570.     const tracksChangedInitial = this.manifestFilterer_.applyRestrictions(
  571.         this.manifest_);
  572.     if (tracksChangedInitial) {
  573.       const event = this.makeEvent_(
  574.           shaka.util.FakeEvent.EventName.TracksChanged);
  575.       await Promise.resolve();
  576.       this.throwIfDestroyed_();
  577.       this.dispatchEvent(event);
  578.     }
  580.     const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
  581.         this.manifest_.variants);
  582.     await this.drmEngine_.initForPlayback(
  583.         playableVariants,
  584.         this.manifest_.offlineSessionIds);
  585.     this.throwIfDestroyed_();
  586.     if (media) {
  587.       await this.drmEngine_.attach(media);
  588.       this.throwIfDestroyed_();
  589.     }
  591.     // Now that we have drm information, filter the manifest (again) so that
  592.     // we can ensure we only use variants with the selected key system.
  593.     const tracksChangedAfter = await this.manifestFilterer_.filterManifest(
  594.         this.manifest_);
  595.     if (tracksChangedAfter) {
  596.       const event = this.makeEvent_(
  597.           shaka.util.FakeEvent.EventName.TracksChanged);
  598.       await Promise.resolve();
  599.       this.dispatchEvent(event);
  600.     }
  601.   }
  603.   /** @param {!shaka.extern.PlayerConfiguration} config */
  604.   reconfigure(config) {
  605.     this.config_ = config;
  606.   }
  608.   /**
  609.    * @param {string} name
  610.    * @param {*=} value
  611.    */
  612.   configure(name, value) {
  613.     const config = shaka.util.ConfigUtils.convertToConfigObject(name, value);
  614.     shaka.util.PlayerConfiguration.mergeConfigObjects(this.config_, config);
  615.   }
  617.   /**
  618.    * Return a copy of the current configuration.
  619.    *
  620.    * @return {shaka.extern.PlayerConfiguration}
  621.    */
  622.   getConfiguration() {
  623.     return shaka.util.ObjectUtils.cloneObject(this.config_);
  624.   }
  626.   /**
  627.    * Performs a final filtering of the manifest, and chooses the initial
  628.    * variant. Also prefetches segments.
  629.    *
  630.    * @return {!Promise}
  631.    * @private
  632.    */
  633.   async chooseInitialVariantAndPrefetchInner_() {
  634.     goog.asserts.assert(
  635.         this.manifest_, 'The manifest should already be parsed.');
  637.     // This step does not have any associated events, as it is only part of the
  638.     // "load" state in the old state graph.
  640.     if (!this.currentAdaptationSetCriteria_) {
  641.       // Copy preferred languages from the config again, in case the config was
  642.       // changed between construction and playback.
  643.       this.currentAdaptationSetCriteria_ =
  644.           new shaka.media.PreferenceBasedCriteria(
  645.               this.config_.preferredAudioLanguage,
  646.               this.config_.preferredVariantRole,
  647.               this.config_.preferredAudioChannelCount,
  648.               this.config_.preferredVideoHdrLevel,
  649.               this.config_.preferSpatialAudio,
  650.               this.config_.preferredVideoLayout,
  651.               this.config_.preferredAudioLabel,
  652.               this.config_.preferredVideoLabel,
  653.               this.config_.mediaSource.codecSwitchingStrategy,
  654.               /* audioCodec= */ '');
  655.     }
  657.     // Make the ABR manager.
  658.     if (this.allowMakeAbrManager_) {
  659.       const abrFactory = this.config_.abrFactory;
  660.       this.abrManagerFactory_ = abrFactory;
  661.       this.abrManager_ = abrFactory();
  662.       this.abrManager_.configure(this.config_.abr);
  663.     }
  665.     if (this.allowPrefetch_) {
  666.       const isLive = this.manifest_.presentationTimeline.isLive();
  667.       // Prefetch segments for the predicted first variant.
  668.       // We start these here, but don't wait for them; it's okay to start the
  669.       // full load process while the segments are being prefetched.
  670.       const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
  671.           this.manifest_.variants);
  672.       const adaptationSet = this.currentAdaptationSetCriteria_.create(
  673.           playableVariants);
  674.       // Guess what the first variant will be, based on a SimpleAbrManager.
  675.       this.abrManager_.configure(this.config_.abr);
  676.       this.abrManager_.setVariants(Array.from(adaptationSet.values()));
  677.       const variant = this.abrManager_.chooseVariant();
  678.       if (variant) {
  679.         const promises = [];
  680.         this.prefetchedVariant_ = variant;
  681.         if (variant.video) {
  682.           promises.push(this.prefetchStream_(variant.video, isLive));
  683.         }
  684.         if (variant.audio) {
  685.           promises.push(this.prefetchStream_(variant.audio, isLive));
  686.         }
  687.         await Promise.all(promises);
  688.       }
  689.     }
  690.   }
  692.   /**
  693.    * @param {!shaka.extern.Stream} stream
  694.    * @param {boolean} isLive
  695.    * @return {!Promise}
  696.    * @private
  697.    */
  698.   async prefetchStream_(stream, isLive) {
  699.     // Use the prefetch limit from the config if this is set, otherwise use 2.
  700.     const prefetchLimit = this.config_.streaming.segmentPrefetchLimit || 2;
  701.     const prefetch = new shaka.media.SegmentPrefetch(
  702.         prefetchLimit, stream, (reference, stream, streamDataCallback) => {
  703.           return shaka.media.StreamingEngine.dispatchFetch(
  704.               reference, stream, streamDataCallback || null,
  705.               this.config_.streaming.retryParameters, this.networkingEngine_,
  706.               this.isPreload_);
  707.         }, /* reverse= */ false);
  708.     this.segmentPrefetchById_.set(stream.id, prefetch);
  710.     // Start prefetching a bit.
  711.     await stream.createSegmentIndex();
  712.     const startTime = this.startTime_ || 0;
  713.     const prefetchSegmentIterator =
  714.         stream.segmentIndex.getIteratorForTime(startTime);
  715.     let prefetchSegment =
  716.         prefetchSegmentIterator ? prefetchSegmentIterator.current() : null;
  717.     if (!prefetchSegment) {
  718.       // If we can't get a segment at the desired spot, at least get a segment,
  719.       // so we can get the init segment.
  720.       prefetchSegment = stream.segmentIndex.earliestReference();
  721.     }
  722.     if (prefetchSegment) {
  723.       if (isLive) {
  724.         // Preload only the init segment for Live
  725.         if (prefetchSegment.initSegmentReference) {
  726.           await prefetch.prefetchInitSegment(
  727.               prefetchSegment.initSegmentReference);
  728.         }
  729.       } else {
  730.         // Preload a segment, too... either the first segment, or the segment
  731.         // that corresponds with this.startTime_, as appropriate.
  732.         // Note: this method also preload the init segment
  733.         await prefetch.prefetchSegmentsByTime(prefetchSegment.startTime);
  734.       }
  735.     }
  736.   }
  738.   /**
  739.    * Waits for the loading to be finished (or to fail with an error).
  740.    * @return {!Promise}
  741.    * @export
  742.    */
  743.   waitForFinish() {
  744.     return this.successPromise_;
  745.   }
  747.   /**
  748.    * Waits for the manifest to be loaded (or to fail with an error).
  749.    * @return {!Promise}
  750.    */
  751.   waitForManifest() {
  752.     const promises = [
  753.       this.manifestPromise_,
  754.       this.successPromise_,
  755.     ];
  756.     return Promise.race(promises);
  757.   }
  759.   /**
  760.    * Releases or stops all non-entrusted resources.
  761.    *
  762.    * @override
  763.    * @export
  764.    */
  765.   async destroy() {
  766.     this.destroyed_ = true;
  767.     if (this.parser_ && !this.parserEntrusted_) {
  768.       await this.parser_.stop();
  769.     }
  770.     if (this.abrManager_ && !this.abrManagerEntrusted_) {
  771.       await this.abrManager_.stop();
  772.     }
  773.     if (this.regionTimeline_ && !this.regionTimelineEntrusted_) {
  774.       this.regionTimeline_.release();
  775.     }
  776.     if (this.drmEngine_ && !this.drmEngineEntrusted_) {
  777.       await this.drmEngine_.destroy();
  778.     }
  779.     if (this.segmentPrefetchById_.size > 0 && !this.segmentPrefetchEntrusted_) {
  780.       for (const segmentPrefetch of this.segmentPrefetchById_.values()) {
  781.         segmentPrefetch.clearAll();
  782.       }
  783.     }
  784.     // this.eventHandoffTarget_ is not unset, so that events and errors fired
  785.     // after the preload manager is destroyed will still be routed to the
  786.     // player, if it was once linked up.
  787.   }
  789.   /** @return {boolean} */
  790.   isDestroyed() {
  791.     return this.destroyed_;
  792.   }
  794.   /** @return {boolean} */
  795.   hasBeenAttached() {
  796.     return this.hasBeenAttached_;
  797.   }
  799.   /**
  800.    * Take a series of variants and ensure that they only contain one type of
  801.    * variant. The different options are:
  802.    *  1. Audio-Video
  803.    *  2. Audio-Only
  804.    *  3. Video-Only
  805.    *
  806.    * A manifest can only contain a single type because once we initialize media
  807.    * source to expect specific streams, it must always have content for those
  808.    * streams. If we were to start with audio+video and switch to an audio-only
  809.    * variant, media source would block waiting for video content.
  810.    *
  811.    * @param {shaka.extern.Manifest} manifest
  812.    * @private
  813.    */
  814.   static filterForAVVariants_(manifest) {
  815.     const isAVVariant = (variant) => {
  816.       // Audio-video variants may include both streams separately or may be
  817.       // single multiplexed streams with multiple codecs.
  818.       return (variant.video && variant.audio) ||
  819.              (variant.video && variant.video.codecs.includes(','));
  820.     };
  821.     if (manifest.variants.some(isAVVariant)) {
  822.       shaka.log.debug('Found variant with audio and video content, ' +
  823.           'so filtering out audio-only content.');
  824.       manifest.variants = manifest.variants.filter(isAVVariant);
  825.     }
  826.   }
  827. };
  829. /**
  830.  * @typedef {{
  831.  *   config: !shaka.extern.PlayerConfiguration,
  832.  *   manifestPlayerInterface: !shaka.extern.ManifestParser.PlayerInterface,
  833.  *   regionTimeline: !shaka.media.RegionTimeline,
  834.  *   qualityObserver: ?shaka.media.QualityObserver,
  835.  *   createDrmEngine: function():!shaka.media.DrmEngine,
  836.  *   networkingEngine: !shaka.net.NetworkingEngine,
  837.  *   manifestFilterer: !shaka.media.ManifestFilterer,
  838.  *   allowPrefetch: boolean,
  839.  *   allowMakeAbrManager: boolean
  840.  * }}
  841.  *
  842.  * @property {!shaka.extern.PlayerConfiguration} config
  843.  * @property {!shaka.extern.ManifestParser.PlayerInterface}
  844.  *   manifestPlayerInterface
  845.  * @property {!shaka.media.RegionTimeline} regionTimeline
  846.  * @property {?shaka.media.QualityObserver} qualityObserver
  847.  * @property {function():!shaka.media.DrmEngine} createDrmEngine
  848.  * @property {!shaka.net.NetworkingEngine} networkingEngine
  849.  * @property {!shaka.media.ManifestFilterer} manifestFilterer
  850.  * @property {boolean} allowPrefetch
  851.  * @property {boolean} allowMakeAbrManager
  852.  */
  853. shaka.media.PreloadManager.PlayerInterface;