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.PlayerConfiguration');
  33. /**
  34.  * @implements {shaka.util.IDestroyable}
  35.  * @export
  36.  */
  37. shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
  38.   /**
  39.    * @param {string} assetUri
  40.    * @param {?string} mimeType
  41.    * @param {?number} startTime
  42.    * @param {*} playerInterface
  43.    */
  44.   constructor(assetUri, mimeType, startTime, playerInterface) {
  45.     super();
  47.     // Making the playerInterface a * and casting it to the right type allows
  48.     // for the PlayerInterface for this class to not be exported.
  49.     // Unfortunately, the constructor is exported by default.
  50.     const typedPlayerInterface =
  51.     /** @type {!shaka.media.PreloadManager.PlayerInterface} */ (
  52.         playerInterface);
  54.     /** @private {string} */
  55.     this.assetUri_ = assetUri;
  57.     /** @private {?string} */
  58.     this.mimeType_ = mimeType;
  60.     /** @private {!shaka.net.NetworkingEngine} */
  61.     this.networkingEngine_ = typedPlayerInterface.networkingEngine;
  63.     /** @private {?number} */
  64.     this.startTime_ = startTime;
  66.     /** @private {?shaka.media.AdaptationSetCriteria} */
  67.     this.currentAdaptationSetCriteria_ = null;
  69.     /** @private {number} */
  70.     this.startTimeOfDrm_ = 0;
  72.     /** @private {function():!shaka.media.DrmEngine} */
  73.     this.createDrmEngine_ = typedPlayerInterface.createDrmEngine;
  75.     /** @private {!shaka.media.ManifestFilterer} */
  76.     this.manifestFilterer_ = typedPlayerInterface.manifestFilterer;
  78.     /** @private {!shaka.extern.ManifestParser.PlayerInterface} */
  79.     this.manifestPlayerInterface_ =
  80.         typedPlayerInterface.manifestPlayerInterface;
  82.     /** @private {!shaka.extern.PlayerConfiguration} */
  83.     this.config_ = typedPlayerInterface.config;
  85.     /** @private {?shaka.extern.Manifest} */
  86.     this.manifest_ = null;
  88.     /** @private {?shaka.extern.ManifestParser.Factory} */
  89.     this.parserFactory_ = null;
  91.     /** @private {?shaka.extern.ManifestParser} */
  92.     this.parser_ = null;
  94.     /** @private {boolean} */
  95.     this.parserEntrusted_ = false;
  97.     /** @private {!shaka.media.RegionTimeline} */
  98.     this.regionTimeline_ = typedPlayerInterface.regionTimeline;
  100.     /** @private {boolean} */
  101.     this.regionTimelineEntrusted_ = false;
  103.     /** @private {?shaka.media.DrmEngine} */
  104.     this.drmEngine_ = null;
  106.     /** @private {boolean} */
  107.     this.drmEngineEntrusted_ = false;
  109.     /** @private {?shaka.extern.AbrManager.Factory} */
  110.     this.abrManagerFactory_ = null;
  112.     /** @private {shaka.extern.AbrManager} */
  113.     this.abrManager_ = null;
  115.     /** @private {boolean} */
  116.     this.abrManagerEntrusted_ = false;
  118.     /** @private {!Map.<number, shaka.media.SegmentPrefetch>} */
  119.     this.segmentPrefetchById_ = new Map();
  121.     /** @private {boolean} */
  122.     this.segmentPrefetchEntrusted_ = false;
  124.     /** @private {?shaka.media.QualityObserver} */
  125.     this.qualityObserver_ = typedPlayerInterface.qualityObserver;
  127.     /** @private {!shaka.util.Stats} */
  128.     this.stats_ = new shaka.util.Stats();
  130.     /** @private {!shaka.util.PublicPromise} */
  131.     this.manifestPromise_ = new shaka.util.PublicPromise();
  133.     /** @private {!shaka.util.PublicPromise} */
  134.     this.successPromise_ = new shaka.util.PublicPromise();
  136.     /** @private {?shaka.util.FakeEventTarget} */
  137.     this.eventHandoffTarget_ = null;
  139.     /** @private {boolean} */
  140.     this.destroyed_ = false;
  142.     /** @private {boolean} */
  143.     this.allowPrefetch_ = typedPlayerInterface.allowPrefetch;
  145.     /** @private {?shaka.extern.Variant} */
  146.     this.prefetchedVariant_ = null;
  148.     /** @private {boolean} */
  149.     this.allowMakeAbrManager_ = typedPlayerInterface.allowMakeAbrManager;
  151.     /** @private {boolean} */
  152.     this.hasBeenAttached_ = false;
  154.     /** @private {?Array.<function()>} */
  155.     this.queuedOperations_ = [];
  157.     /** @private {?Array.<function()>} */
  158.     this.latePhaseQueuedOperations_ = [];
  160.     /** @private {boolean} */
  161.     this.isPreload_ = true;
  162.   }
  164.   /**
  165.    * Makes it so that net requests launched from this load will no longer be
  166.    * marked as "isPreload"
  167.    */
  168.   markIsLoad() {
  169.     this.isPreload_ = false;
  170.   }
  172.   /**
  173.    * @param {boolean} latePhase
  174.    * @param {function()} callback
  175.    */
  176.   addQueuedOperation(latePhase, callback) {
  177.     const queue =
  178.         latePhase ? this.latePhaseQueuedOperations_ : this.queuedOperations_;
  179.     if (queue) {
  180.       queue.push(callback);
  181.     } else {
  182.       callback();
  183.     }
  184.   }
  186.   /** Calls all late phase queued operations, and stops queueing them. */
  187.   stopQueuingLatePhaseQueuedOperations() {
  188.     if (this.latePhaseQueuedOperations_) {
  189.       for (const callback of this.latePhaseQueuedOperations_) {
  190.         callback();
  191.       }
  192.     }
  193.     this.latePhaseQueuedOperations_ = null;
  194.   }
  196.   /** @param {!shaka.util.FakeEventTarget} eventHandoffTarget */
  197.   setEventHandoffTarget(eventHandoffTarget) {
  198.     this.eventHandoffTarget_ = eventHandoffTarget;
  199.     this.hasBeenAttached_ = true;
  200.     // Also call all queued operations, and stop queuing them in the future.
  201.     if (this.queuedOperations_) {
  202.       for (const callback of this.queuedOperations_) {
  203.         callback();
  204.       }
  205.     }
  206.     this.queuedOperations_ = null;
  207.   }
  209.   /** @param {number} offset */
  210.   setOffsetToStartTime(offset) {
  211.     if (this.startTime_ && offset) {
  212.       this.startTime_ += offset;
  213.     }
  214.   }
  216.   /** @return {?number} */
  217.   getStartTime() {
  218.     return this.startTime_;
  219.   }
  221.   /** @return {number} */
  222.   getStartTimeOfDRM() {
  223.     return this.startTimeOfDrm_;
  224.   }
  226.   /** @return {?string} */
  227.   getMimeType() {
  228.     return this.mimeType_;
  229.   }
  231.   /** @return {string} */
  232.   getAssetUri() {
  233.     return this.assetUri_;
  234.   }
  236.   /** @return {?shaka.extern.Manifest} */
  237.   getManifest() {
  238.     return this.manifest_;
  239.   }
  241.   /** @return {?shaka.extern.ManifestParser.Factory} */
  242.   getParserFactory() {
  243.     return this.parserFactory_;
  244.   }
  246.   /** @return {?shaka.media.AdaptationSetCriteria} */
  247.   getCurrentAdaptationSetCriteria() {
  248.     return this.currentAdaptationSetCriteria_;
  249.   }
  251.   /** @return {?shaka.extern.AbrManager.Factory} */
  252.   getAbrManagerFactory() {
  253.     return this.abrManagerFactory_;
  254.   }
  256.   /**
  257.    * Gets the abr manager, if it exists. Also marks that the abr manager should
  258.    * not be stopped if this manager is destroyed.
  259.    * @return {?shaka.extern.AbrManager}
  260.    */
  261.   receiveAbrManager() {
  262.     this.abrManagerEntrusted_ = true;
  263.     return this.abrManager_;
  264.   }
  266.   /**
  267.    * @return {?shaka.extern.AbrManager}
  268.    */
  269.   getAbrManager() {
  270.     return this.abrManager_;
  271.   }
  273.   /**
  274.    * Gets the parser, if it exists. Also marks that the parser should not be
  275.    * stopped if this manager is destroyed.
  276.    * @return {?shaka.extern.ManifestParser}
  277.    */
  278.   receiveParser() {
  279.     this.parserEntrusted_ = true;
  280.     return this.parser_;
  281.   }
  283.   /**
  284.    * @return {?shaka.extern.ManifestParser}
  285.    */
  286.   getParser() {
  287.     return this.parser_;
  288.   }
  290.   /**
  291.    * Gets the region timeline, if it exists. Also marks that the timeline should
  292.    * not be released if this manager is destroyed.
  293.    * @return {?shaka.media.RegionTimeline}
  294.    */
  295.   receiveRegionTimeline() {
  296.     this.regionTimelineEntrusted_ = true;
  297.     return this.regionTimeline_;
  298.   }
  300.   /**
  301.    * @return {?shaka.media.RegionTimeline}
  302.    */
  303.   getRegionTimeline() {
  304.     return this.regionTimeline_;
  305.   }
  307.   /** @return {?shaka.media.QualityObserver} */
  308.   getQualityObserver() {
  309.     return this.qualityObserver_;
  310.   }
  312.   /** @return {!shaka.util.Stats} */
  313.   getStats() {
  314.     return this.stats_;
  315.   }
  317.   /** @return {!shaka.media.ManifestFilterer} */
  318.   getManifestFilterer() {
  319.     return this.manifestFilterer_;
  320.   }
  322.   /**
  323.    * Gets the drm engine, if it exists. Also marks that the drm engine should
  324.    * not be destroyed if this manager is destroyed.
  325.    * @return {?shaka.media.DrmEngine}
  326.    */
  327.   receiveDrmEngine() {
  328.     this.drmEngineEntrusted_ = true;
  329.     return this.drmEngine_;
  330.   }
  332.   /**
  333.    * @return {?shaka.media.DrmEngine}
  334.    */
  335.   getDrmEngine() {
  336.     return this.drmEngine_;
  337.   }
  339.   /**
  340.    * @return {?shaka.extern.Variant}
  341.    */
  342.   getPrefetchedVariant() {
  343.     return this.prefetchedVariant_;
  344.   }
  346.   /**
  347.    * Gets the SegmentPrefetch objects for the initial stream ids. Also marks
  348.    * that those objects should not be aborted if this manager is destroyed.
  349.    * @return {!Map.<number, shaka.media.SegmentPrefetch>}
  350.    */
  351.   receiveSegmentPrefetchesById() {
  352.     this.segmentPrefetchEntrusted_ = true;
  353.     return this.segmentPrefetchById_;
  354.   }
  356.   /**
  357.    * @param {?shaka.extern.AbrManager} abrManager
  358.    * @param {?shaka.extern.AbrManager.Factory} abrFactory
  359.    */
  360.   attachAbrManager(abrManager, abrFactory) {
  361.     this.abrManager_ = abrManager;
  362.     this.abrManagerFactory_ = abrFactory;
  363.   }
  365.   /**
  366.    * @param {?shaka.media.AdaptationSetCriteria} adaptationSetCriteria
  367.    */
  368.   attachAdaptationSetCriteria(adaptationSetCriteria) {
  369.     this.currentAdaptationSetCriteria_ = adaptationSetCriteria;
  370.   }
  372.   /**
  373.    * @param {!shaka.extern.Manifest} manifest
  374.    * @param {!shaka.extern.ManifestParser} parser
  375.    * @param {!shaka.extern.ManifestParser.Factory} parserFactory
  376.    */
  377.   attachManifest(manifest, parser, parserFactory) {
  378.     this.manifest_ = manifest;
  379.     this.parser_ = parser;
  380.     this.parserFactory_ = parserFactory;
  381.   }
  383.   /**
  384.    * Starts the process of loading the asset.
  385.    * Success or failure will be measured through waitForFinish()
  386.    */
  387.   start() {
  388.     (async () => {
  389.       // Force a context switch, to give the player a chance to hook up events
  390.       // immediately if desired.
  391.       await Promise.resolve();
  393.       // Perform the preloading process.
  394.       try {
  395.         await this.parseManifestInner_();
  396.         this.throwIfDestroyed_();
  398.         await this.initializeDrmInner_();
  399.         this.throwIfDestroyed_();
  401.         await this.chooseInitialVariantInner_();
  402.         this.throwIfDestroyed_();
  404.         this.successPromise_.resolve();
  405.       } catch (error) {
  406.         this.successPromise_.reject(error);
  407.       }
  408.     })();
  409.   }
  411.   /**
  412.    * @param {!Event} event
  413.    * @return {boolean}
  414.    * @override
  415.    */
  416.   dispatchEvent(event) {
  417.     if (this.eventHandoffTarget_) {
  418.       return this.eventHandoffTarget_.dispatchEvent(event);
  419.     } else {
  420.       return super.dispatchEvent(event);
  421.     }
  422.   }
  424.   /**
  425.    * @param {!shaka.util.Error} error
  426.    */
  427.   onError(error) {
  428.     if (error.severity === shaka.util.Error.Severity.CRITICAL) {
  429.       // Cancel the loading process.
  430.       this.successPromise_.reject(error);
  431.       this.destroy();
  432.     }
  434.     const eventName = shaka.util.FakeEvent.EventName.Error;
  435.     const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
  436.     this.dispatchEvent(event);
  437.     if (event.defaultPrevented) {
  438.       error.handled = true;
  439.     }
  440.   }
  442.   /**
  443.    * Throw if destroyed, to interrupt processes with a recognizable error.
  444.    *
  445.    * @private
  446.    */
  447.   throwIfDestroyed_() {
  448.     if (this.isDestroyed()) {
  449.       throw new shaka.util.Error(
  450.           shaka.util.Error.Severity.CRITICAL,
  451.           shaka.util.Error.Category.PLAYER,
  452.           shaka.util.Error.Code.OBJECT_DESTROYED);
  453.     }
  454.   }
  456.   /**
  457.    * Makes a fires an event corresponding to entering a state of the loading
  458.    * process.
  459.    * @param {string} nodeName
  460.    * @private
  461.    */
  462.   makeStateChangeEvent_(nodeName) {
  463.     this.dispatchEvent(new shaka.util.FakeEvent(
  464.         /* name= */ shaka.util.FakeEvent.EventName.OnStateChange,
  465.         /* data= */ (new Map()).set('state', nodeName)));
  466.   }
  468.   /**
  469.    * @param {!shaka.util.FakeEvent.EventName} name
  470.    * @param {Map.<string, Object>=} data
  471.    * @return {!shaka.util.FakeEvent}
  472.    * @private
  473.    */
  474.   makeEvent_(name, data) {
  475.     return new shaka.util.FakeEvent(name, data);
  476.   }
  478.   /**
  479.    * Pick and initialize a manifest parser, then have it download and parse the
  480.    * manifest.
  481.    *
  482.    * @return {!Promise}
  483.    * @private
  484.    */
  485.   async parseManifestInner_() {
  486.     this.makeStateChangeEvent_('manifest-parser');
  488.     if (!this.parser_) {
  489.       // Create the parser that we will use to parse the manifest.
  490.       this.parserFactory_ = shaka.media.ManifestParser.getFactory(
  491.           this.assetUri_, this.mimeType_);
  492.       goog.asserts.assert(this.parserFactory_, 'Must have manifest parser');
  493.       this.parser_ = this.parserFactory_();
  495.       this.parser_.configure(this.config_.manifest, () => this.isPreload_);
  496.     }
  498.     const startTime = Date.now() / 1000;
  500.     this.makeStateChangeEvent_('manifest');
  502.     if (!this.manifest_) {
  503.       this.manifest_ = await this.parser_.start(
  504.           this.assetUri_, this.manifestPlayerInterface_);
  505.     }
  507.     this.manifestPromise_.resolve();
  509.     // This event is fired after the manifest is parsed, but before any
  510.     // filtering takes place.
  511.     const event =
  512.           this.makeEvent_(shaka.util.FakeEvent.EventName.ManifestParsed);
  513.     // Delay event to ensure manifest has been properly propagated
  514.     // to the player.
  515.     await Promise.resolve();
  516.     this.dispatchEvent(event);
  518.     // We require all manifests to have at least one variant.
  519.     if (this.manifest_.variants.length == 0) {
  520.       throw new shaka.util.Error(
  521.           shaka.util.Error.Severity.CRITICAL,
  522.           shaka.util.Error.Category.MANIFEST,
  523.           shaka.util.Error.Code.NO_VARIANTS);
  524.     }
  526.     // Make sure that all variants are either: audio-only, video-only, or
  527.     // audio-video.
  528.     shaka.media.PreloadManager.filterForAVVariants_(this.manifest_);
  530.     const now = Date.now() / 1000;
  531.     const delta = now - startTime;
  532.     this.stats_.setManifestTime(delta);
  533.   }
  535.   /**
  536.    * Initializes the DRM engine.
  537.    *
  538.    * @return {!Promise}
  539.    * @private
  540.    */
  541.   async initializeDrmInner_() {
  542.     goog.asserts.assert(
  543.         this.manifest_, 'The manifest should already be parsed.');
  545.     this.makeStateChangeEvent_('drm-engine');
  547.     this.startTimeOfDrm_ = Date.now() / 1000;
  549.     this.drmEngine_ = this.createDrmEngine_();
  550.     this.manifestFilterer_.setDrmEngine(this.drmEngine_);
  552.     this.drmEngine_.configure(this.config_.drm, () => this.isPreload_);
  554.     const tracksChangedInitial = this.manifestFilterer_.applyRestrictions(
  555.         this.manifest_);
  556.     if (tracksChangedInitial) {
  557.       const event = this.makeEvent_(
  558.           shaka.util.FakeEvent.EventName.TracksChanged);
  559.       await Promise.resolve();
  560.       this.throwIfDestroyed_();
  561.       this.dispatchEvent(event);
  562.     }
  564.     const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
  565.         this.manifest_.variants);
  566.     await this.drmEngine_.initForPlayback(
  567.         playableVariants,
  568.         this.manifest_.offlineSessionIds);
  569.     this.throwIfDestroyed_();
  571.     // Now that we have drm information, filter the manifest (again) so that
  572.     // we can ensure we only use variants with the selected key system.
  573.     const tracksChangedAfter = await this.manifestFilterer_.filterManifest(
  574.         this.manifest_);
  575.     if (tracksChangedAfter) {
  576.       const event = this.makeEvent_(
  577.           shaka.util.FakeEvent.EventName.TracksChanged);
  578.       await Promise.resolve();
  579.       this.dispatchEvent(event);
  580.     }
  581.   }
  583.   /** @param {!shaka.extern.PlayerConfiguration} config */
  584.   reconfigure(config) {
  585.     this.config_ = config;
  586.   }
  588.   /**
  589.    * @param {string} name
  590.    * @param {*=} value
  591.    */
  592.   configure(name, value) {
  593.     const config = shaka.util.ConfigUtils.convertToConfigObject(name, value);
  594.     shaka.util.PlayerConfiguration.mergeConfigObjects(this.config_, config);
  595.   }
  597.   /**
  598.    * Return a copy of the current configuration.
  599.    *
  600.    * @return {shaka.extern.PlayerConfiguration}
  601.    */
  602.   getConfiguration() {
  603.     return shaka.util.ObjectUtils.cloneObject(this.config_);
  604.   }
  606.   /**
  607.    * Performs a final filtering of the manifest, and chooses the initial
  608.    * variant.
  609.    *
  610.    * @private
  611.    */
  612.   chooseInitialVariantInner_() {
  613.     goog.asserts.assert(
  614.         this.manifest_, 'The manifest should already be parsed.');
  616.     // This step does not have any associated events, as it is only part of the
  617.     // "load" state in the old state graph.
  619.     if (!this.currentAdaptationSetCriteria_) {
  620.       // Copy preferred languages from the config again, in case the config was
  621.       // changed between construction and playback.
  622.       this.currentAdaptationSetCriteria_ =
  623.           new shaka.media.PreferenceBasedCriteria(
  624.               this.config_.preferredAudioLanguage,
  625.               this.config_.preferredVariantRole,
  626.               this.config_.preferredAudioChannelCount,
  627.               this.config_.preferredVideoHdrLevel,
  628.               this.config_.preferSpatialAudio,
  629.               this.config_.preferredVideoLayout,
  630.               this.config_.preferredAudioLabel,
  631.               this.config_.preferredVideoLabel,
  632.               this.config_.mediaSource.codecSwitchingStrategy,
  633.               this.config_.manifest.dash.enableAudioGroups);
  634.     }
  636.     // Make the ABR manager.
  637.     if (this.allowMakeAbrManager_) {
  638.       const abrFactory = this.config_.abrFactory;
  639.       this.abrManagerFactory_ = abrFactory;
  640.       this.abrManager_ = abrFactory();
  641.       this.abrManager_.configure(this.config_.abr);
  642.     }
  644.     if (this.allowPrefetch_) {
  645.       const isLive = this.manifest_.presentationTimeline.isLive();
  646.       // Prefetch segments for the predicted first variant.
  647.       // We start these here, but don't wait for them; it's okay to start the
  648.       // full load process while the segments are being prefetched.
  649.       const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
  650.           this.manifest_.variants);
  651.       const adaptationSet = this.currentAdaptationSetCriteria_.create(
  652.           playableVariants);
  653.       // Guess what the first variant will be, based on a SimpleAbrManager.
  654.       this.abrManager_.configure(this.config_.abr);
  655.       this.abrManager_.setVariants(Array.from(adaptationSet.values()));
  656.       const variant = this.abrManager_.chooseVariant();
  657.       if (variant) {
  658.         this.prefetchedVariant_ = variant;
  659.         if (variant.video) {
  660.           this.makePrefetchForStream_(variant.video, isLive);
  661.         }
  662.         if (variant.audio) {
  663.           this.makePrefetchForStream_(variant.audio, isLive);
  664.         }
  665.       }
  666.     }
  667.   }
  669.   /**
  670.    * @param {!shaka.extern.Stream} stream
  671.    * @param {boolean} isLive
  672.    * @return {!Promise}
  673.    * @private
  674.    */
  675.   async makePrefetchForStream_(stream, isLive) {
  676.     // Use the prefetch limit from the config if this is set, otherwise use 2.
  677.     const prefetchLimit = this.config_.streaming.segmentPrefetchLimit || 2;
  678.     const prefetch = new shaka.media.SegmentPrefetch(
  679.         prefetchLimit, stream, (reference, stream, streamDataCallback) => {
  680.           return shaka.media.StreamingEngine.dispatchFetch(
  681.               reference, stream, streamDataCallback || null,
  682.               this.config_.streaming.retryParameters, this.networkingEngine_,
  683.               this.isPreload_);
  684.         }, /* reverse= */ false);
  685.     this.segmentPrefetchById_.set(stream.id, prefetch);
  687.     // Start prefetching a bit.
  688.     await stream.createSegmentIndex();
  689.     const startTime = this.startTime_ || 0;
  690.     const prefetchSegmentIterator =
  691.         stream.segmentIndex.getIteratorForTime(startTime);
  692.     let prefetchSegment =
  693.         prefetchSegmentIterator ? prefetchSegmentIterator.current() : null;
  694.     if (!prefetchSegment) {
  695.       // If we can't get a segment at the desired spot, at least get a segment,
  696.       // so we can get the init segment.
  697.       prefetchSegment = stream.segmentIndex.earliestReference();
  698.     }
  699.     if (prefetchSegment) {
  700.       if (isLive) {
  701.         // Preload only the init segment for Live
  702.         if (prefetchSegment.initSegmentReference) {
  703.           prefetch.prefetchInitSegment(prefetchSegment.initSegmentReference);
  704.         }
  705.       } else {
  706.         // Preload a segment, too... either the first segment, or the segment
  707.         // that corresponds with this.startTime_, as appropriate.
  708.         // Note: this method also preload the init segment
  709.         prefetch.prefetchSegmentsByTime(prefetchSegment.startTime);
  710.       }
  711.     }
  712.   }
  714.   /**
  715.    * Waits for the loading to be finished (or to fail with an error).
  716.    * @return {!Promise}
  717.    * @export
  718.    */
  719.   waitForFinish() {
  720.     return this.successPromise_;
  721.   }
  723.   /**
  724.    * Waits for the manifest to be loaded (or to fail with an error).
  725.    * @return {!Promise}
  726.    */
  727.   waitForManifest() {
  728.     const promises = [
  729.       this.manifestPromise_,
  730.       this.successPromise_,
  731.     ];
  732.     return Promise.race(promises);
  733.   }
  735.   /**
  736.    * Releases or stops all non-entrusted resources.
  737.    *
  738.    * @override
  739.    * @export
  740.    */
  741.   async destroy() {
  742.     this.destroyed_ = true;
  743.     if (this.parser_ && !this.parserEntrusted_) {
  744.       await this.parser_.stop();
  745.     }
  746.     if (this.abrManager_ && !this.abrManagerEntrusted_) {
  747.       await this.abrManager_.stop();
  748.     }
  749.     if (this.regionTimeline_ && !this.regionTimelineEntrusted_) {
  750.       this.regionTimeline_.release();
  751.     }
  752.     if (this.drmEngine_ && !this.drmEngineEntrusted_) {
  753.       await this.drmEngine_.destroy();
  754.     }
  755.     if (this.segmentPrefetchById_.size > 0 && !this.segmentPrefetchEntrusted_) {
  756.       for (const segmentPrefetch of this.segmentPrefetchById_.values()) {
  757.         segmentPrefetch.clearAll();
  758.       }
  759.     }
  760.     // this.eventHandoffTarget_ is not unset, so that events and errors fired
  761.     // after the preload manager is destroyed will still be routed to the
  762.     // player, if it was once linked up.
  763.   }
  765.   /** @return {boolean} */
  766.   isDestroyed() {
  767.     return this.destroyed_;
  768.   }
  770.   /** @return {boolean} */
  771.   hasBeenAttached() {
  772.     return this.hasBeenAttached_;
  773.   }
  775.   /**
  776.    * Take a series of variants and ensure that they only contain one type of
  777.    * variant. The different options are:
  778.    *  1. Audio-Video
  779.    *  2. Audio-Only
  780.    *  3. Video-Only
  781.    *
  782.    * A manifest can only contain a single type because once we initialize media
  783.    * source to expect specific streams, it must always have content for those
  784.    * streams. If we were to start with audio+video and switch to an audio-only
  785.    * variant, media source would block waiting for video content.
  786.    *
  787.    * @param {shaka.extern.Manifest} manifest
  788.    * @private
  789.    */
  790.   static filterForAVVariants_(manifest) {
  791.     const isAVVariant = (variant) => {
  792.       // Audio-video variants may include both streams separately or may be
  793.       // single multiplexed streams with multiple codecs.
  794.       return (variant.video && variant.audio) ||
  795.              (variant.video && variant.video.codecs.includes(','));
  796.     };
  797.     if (manifest.variants.some(isAVVariant)) {
  798.       shaka.log.debug('Found variant with audio and video content, ' +
  799.           'so filtering out audio-only content.');
  800.       manifest.variants = manifest.variants.filter(isAVVariant);
  801.     }
  802.   }
  803. };
  805. /**
  806.  * @typedef {{
  807.  *   config: !shaka.extern.PlayerConfiguration,
  808.  *   manifestPlayerInterface: !shaka.extern.ManifestParser.PlayerInterface,
  809.  *   regionTimeline: !shaka.media.RegionTimeline,
  810.  *   qualityObserver: ?shaka.media.QualityObserver,
  811.  *   createDrmEngine: function():!shaka.media.DrmEngine,
  812.  *   networkingEngine: !shaka.net.NetworkingEngine,
  813.  *   manifestFilterer: !shaka.media.ManifestFilterer,
  814.  *   allowPrefetch: boolean,
  815.  *   allowMakeAbrManager: boolean
  816.  * }}
  817.  *
  818.  * @property {!shaka.extern.PlayerConfiguration} config
  819.  * @property {!shaka.extern.ManifestParser.PlayerInterface}
  820.  *   manifestPlayerInterface
  821.  * @property {!shaka.media.RegionTimeline} regionTimeline
  822.  * @property {?shaka.media.QualityObserver} qualityObserver
  823.  * @property {function():!shaka.media.DrmEngine} createDrmEngine
  824.  * @property {!shaka.net.NetworkingEngine} networkingEngine
  825.  * @property {!shaka.media.ManifestFilterer} manifestFilterer
  826.  * @property {boolean} allowPrefetch
  827.  * @property {boolean} allowMakeAbrManager
  828.  */
  829. shaka.media.PreloadManager.PlayerInterface;