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