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