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