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.drm.DrmEngine');
  11. goog.require('shaka.drm.DrmUtils');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.AdaptationSetCriteria');
  14. goog.require('shaka.media.ManifestFilterer');
  15. goog.require('shaka.media.ManifestParser');
  16. goog.require('shaka.media.QualityObserver');
  17. goog.require('shaka.media.RegionTimeline');
  18. goog.require('shaka.media.SegmentPrefetch');
  19. goog.require('shaka.media.StreamingEngine');
  20. goog.require('shaka.net.NetworkingEngine');
  21. goog.require('shaka.util.ConfigUtils');
  22. goog.require('shaka.util.Error');
  23. goog.require('shaka.util.FakeEvent');
  24. goog.require('shaka.util.FakeEventTarget');
  25. goog.require('shaka.util.IDestroyable');
  26. goog.require('shaka.util.ObjectUtils');
  27. goog.require('shaka.util.PlayerConfiguration');
  28. goog.require('shaka.util.PublicPromise');
  29. goog.require('shaka.util.Stats');
  30. goog.require('shaka.util.StreamUtils');
  32. /**
  33.  * @implements {shaka.util.IDestroyable}
  34.  * @export
  35.  */
  36. shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
  37.   /**
  38.    * @param {string} assetUri
  39.    * @param {?string} mimeType
  40.    * @param {?number} startTime
  41.    * @param {*} playerInterface
  42.    */
  43.   constructor(assetUri, mimeType, startTime, playerInterface) {
  44.     super();
  46.     // Making the playerInterface a * and casting it to the right type allows
  47.     // for the PlayerInterface for this class to not be exported.
  48.     // Unfortunately, the constructor is exported by default.
  49.     const typedPlayerInterface =
  50.     /** @type {!shaka.media.PreloadManager.PlayerInterface} */ (
  51.         playerInterface);
  53.     /** @private {string} */
  54.     this.assetUri_ = assetUri;
  56.     /** @private {?string} */
  57.     this.mimeType_ = mimeType;
  59.     /** @private {!shaka.net.NetworkingEngine} */
  60.     this.networkingEngine_ = typedPlayerInterface.networkingEngine;
  62.     /** @private {?number} */
  63.     this.startTime_ = startTime;
  65.     /** @private {?shaka.media.AdaptationSetCriteria} */
  66.     this.currentAdaptationSetCriteria_ = null;
  68.     /** @private {number} */
  69.     this.startTimeOfDrm_ = 0;
  71.     /** @private {function():!shaka.drm.DrmEngine} */
  72.     this.createDrmEngine_ = typedPlayerInterface.createDrmEngine;
  74.     /** @private {!shaka.media.ManifestFilterer} */
  75.     this.manifestFilterer_ = typedPlayerInterface.manifestFilterer;
  77.     /** @private {!shaka.extern.ManifestParser.PlayerInterface} */
  78.     this.manifestPlayerInterface_ =
  79.         typedPlayerInterface.manifestPlayerInterface;
  81.     /** @private {!shaka.extern.PlayerConfiguration} */
  82.     this.config_ = typedPlayerInterface.config;
  84.     /** @private {?shaka.extern.Manifest} */
  85.     this.manifest_ = null;
  87.     /** @private {?shaka.extern.ManifestParser.Factory} */
  88.     this.parserFactory_ = null;
  90.     /** @private {?shaka.extern.ManifestParser} */
  91.     this.parser_ = null;
  93.     /** @private {boolean} */
  94.     this.parserEntrusted_ = false;
  96.     /**
  97.      * @private {!shaka.media.RegionTimeline<
  98.      *     shaka.extern.TimelineRegionInfo>}
  99.      */
  100.     this.regionTimeline_ = typedPlayerInterface.regionTimeline;
  102.     /** @private {boolean} */
  103.     this.regionTimelineEntrusted_ = false;
  105.     /** @private {?shaka.drm.DrmEngine} */
  106.     this.drmEngine_ = null;
  108.     /** @private {boolean} */
  109.     this.drmEngineEntrusted_ = false;
  111.     /** @private {?shaka.extern.AbrManager.Factory} */
  112.     this.abrManagerFactory_ = null;
  114.     /** @private {shaka.extern.AbrManager} */
  115.     this.abrManager_ = null;
  117.     /** @private {boolean} */
  118.     this.abrManagerEntrusted_ = false;
  120.     /** @private {!Map<number, shaka.media.SegmentPrefetch>} */
  121.     this.segmentPrefetchById_ = new Map();
  123.     /** @private {boolean} */
  124.     this.segmentPrefetchEntrusted_ = false;
  126.     /** @private {?shaka.media.QualityObserver} */
  127.     this.qualityObserver_ = typedPlayerInterface.qualityObserver;
  129.     /** @private {!shaka.util.Stats} */
  130.     this.stats_ = new shaka.util.Stats();
  132.     /** @private {!shaka.util.PublicPromise} */
  133.     this.manifestPromise_ = new shaka.util.PublicPromise();
  135.     /** @private {!shaka.util.PublicPromise} */
  136.     this.successPromise_ = new shaka.util.PublicPromise();
  138.     /** @private {?shaka.util.FakeEventTarget} */
  139.     this.eventHandoffTarget_ = null;
  141.     /** @private {boolean} */
  142.     this.destroyed_ = false;
  144.     /** @private {boolean} */
  145.     this.allowPrefetch_ = typedPlayerInterface.allowPrefetch;
  147.     /** @private {?shaka.extern.Variant} */
  148.     this.prefetchedVariant_ = null;
  150.     /** @private {?shaka.extern.Stream} */
  151.     this.prefetchedTextStream_ = null;
  153.     /** @private {boolean} */
  154.     this.allowMakeAbrManager_ = typedPlayerInterface.allowMakeAbrManager;
  156.     /** @private {boolean} */
  157.     this.hasBeenAttached_ = false;
  159.     /** @private {?Array<function()>} */
  160.     this.queuedOperations_ = [];
  162.     /** @private {?Array<function()>} */
  163.     this.latePhaseQueuedOperations_ = [];
  165.     /** @private {boolean} */
  166.     this.isPreload_ = true;
  167.   }
  169.   /**
  170.    * Makes it so that net requests launched from this load will no longer be
  171.    * marked as "isPreload"
  172.    */
  173.   markIsLoad() {
  174.     this.isPreload_ = false;
  175.   }
  177.   /**
  178.    * @param {boolean} latePhase
  179.    * @param {function()} callback
  180.    */
  181.   addQueuedOperation(latePhase, callback) {
  182.     const queue =
  183.         latePhase ? this.latePhaseQueuedOperations_ : this.queuedOperations_;
  184.     if (queue) {
  185.       queue.push(callback);
  186.     } else {
  187.       callback();
  188.     }
  189.   }
  191.   /** Calls all late phase queued operations, and stops queueing them. */
  192.   stopQueuingLatePhaseQueuedOperations() {
  193.     if (this.latePhaseQueuedOperations_) {
  194.       for (const callback of this.latePhaseQueuedOperations_) {
  195.         callback();
  196.       }
  197.     }
  198.     this.latePhaseQueuedOperations_ = null;
  199.   }
  201.   /** @param {!shaka.util.FakeEventTarget} eventHandoffTarget */
  202.   setEventHandoffTarget(eventHandoffTarget) {
  203.     this.eventHandoffTarget_ = eventHandoffTarget;
  204.     this.hasBeenAttached_ = true;
  205.     // Also call all queued operations, and stop queuing them in the future.
  206.     if (this.queuedOperations_) {
  207.       for (const callback of this.queuedOperations_) {
  208.         callback();
  209.       }
  210.     }
  211.     this.queuedOperations_ = null;
  212.   }
  214.   /** @param {number} offset */
  215.   setOffsetToStartTime(offset) {
  216.     if (this.startTime_ && offset) {
  217.       this.startTime_ += offset;
  218.     }
  219.   }
  221.   /** @return {?number} */
  222.   getStartTime() {
  223.     return this.startTime_;
  224.   }
  226.   /** @return {number} */
  227.   getStartTimeOfDRM() {
  228.     return this.startTimeOfDrm_;
  229.   }
  231.   /** @return {?string} */
  232.   getMimeType() {
  233.     return this.mimeType_;
  234.   }
  236.   /** @return {string} */
  237.   getAssetUri() {
  238.     return this.assetUri_;
  239.   }
  241.   /** @return {?shaka.extern.Manifest} */
  242.   getManifest() {
  243.     return this.manifest_;
  244.   }
  246.   /** @return {?shaka.extern.ManifestParser.Factory} */
  247.   getParserFactory() {
  248.     return this.parserFactory_;
  249.   }
  251.   /** @return {?shaka.media.AdaptationSetCriteria} */
  252.   getCurrentAdaptationSetCriteria() {
  253.     return this.currentAdaptationSetCriteria_;
  254.   }
  256.   /** @return {?shaka.extern.AbrManager.Factory} */
  257.   getAbrManagerFactory() {
  258.     return this.abrManagerFactory_;
  259.   }
  261.   /**
  262.    * Gets the abr manager, if it exists. Also marks that the abr manager should
  263.    * not be stopped if this manager is destroyed.
  264.    * @return {?shaka.extern.AbrManager}
  265.    */
  266.   receiveAbrManager() {
  267.     this.abrManagerEntrusted_ = true;
  268.     return this.abrManager_;
  269.   }
  271.   /**
  272.    * @return {?shaka.extern.AbrManager}
  273.    */
  274.   getAbrManager() {
  275.     return this.abrManager_;
  276.   }
  278.   /**
  279.    * Gets the parser, if it exists. Also marks that the parser should not be
  280.    * stopped if this manager is destroyed.
  281.    * @return {?shaka.extern.ManifestParser}
  282.    */
  283.   receiveParser() {
  284.     this.parserEntrusted_ = true;
  285.     return this.parser_;
  286.   }
  288.   /**
  289.    * @return {?shaka.extern.ManifestParser}
  290.    */
  291.   getParser() {
  292.     return this.parser_;
  293.   }
  295.   /**
  296.    * Gets the region timeline, if it exists. Also marks that the timeline should
  297.    * not be released if this manager is destroyed.
  298.    * @return {?shaka.media.RegionTimeline<shaka.extern.TimelineRegionInfo>}
  299.    */
  300.   receiveRegionTimeline() {
  301.     this.regionTimelineEntrusted_ = true;
  302.     return this.regionTimeline_;
  303.   }
  305.   /**
  306.    * @return {?shaka.media.RegionTimeline<shaka.extern.TimelineRegionInfo>}
  307.    */
  308.   getRegionTimeline() {
  309.     return this.regionTimeline_;
  310.   }
  312.   /** @return {?shaka.media.QualityObserver} */
  313.   getQualityObserver() {
  314.     return this.qualityObserver_;
  315.   }
  317.   /** @return {!shaka.util.Stats} */
  318.   getStats() {
  319.     return this.stats_;
  320.   }
  322.   /** @return {!shaka.media.ManifestFilterer} */
  323.   getManifestFilterer() {
  324.     return this.manifestFilterer_;
  325.   }
  327.   /**
  328.    * Gets the drm engine, if it exists. Also marks that the drm engine should
  329.    * not be destroyed if this manager is destroyed.
  330.    * @return {?shaka.drm.DrmEngine}
  331.    */
  332.   receiveDrmEngine() {
  333.     this.drmEngineEntrusted_ = true;
  334.     return this.drmEngine_;
  335.   }
  337.   /**
  338.    * @return {?shaka.drm.DrmEngine}
  339.    */
  340.   getDrmEngine() {
  341.     return this.drmEngine_;
  342.   }
  344.   /**
  345.    * @return {?shaka.extern.Variant}
  346.    */
  347.   getPrefetchedVariant() {
  348.     return this.prefetchedVariant_;
  349.   }
  351.   /**
  352.    * Gets the preloaded variant track if it exists.
  353.    *
  354.    * @return {?shaka.extern.Track}
  355.    * @export
  356.    */
  357.   getPrefetchedVariantTrack() {
  358.     if (!this.prefetchedVariant_) {
  359.       return null;
  360.     }
  361.     return shaka.util.StreamUtils.variantToTrack(this.prefetchedVariant_);
  362.   }
  364.   /**
  365.    * Gets the preloaded text track if it exists.
  366.    *
  367.    * @return {?shaka.extern.Track}
  368.    * @export
  369.    */
  370.   getPrefetchedTextTrack() {
  371.     if (!this.prefetchedTextStream_) {
  372.       return null;
  373.     }
  374.     return shaka.util.StreamUtils.textStreamToTrack(this.prefetchedTextStream_);
  375.   }
  377.   /**
  378.    * Gets the SegmentPrefetch objects for the initial stream ids. Also marks
  379.    * that those objects should not be aborted if this manager is destroyed.
  380.    * @return {!Map<number, shaka.media.SegmentPrefetch>}
  381.    */
  382.   receiveSegmentPrefetchesById() {
  383.     this.segmentPrefetchEntrusted_ = true;
  384.     return this.segmentPrefetchById_;
  385.   }
  387.   /**
  388.    * @param {?shaka.extern.AbrManager} abrManager
  389.    * @param {?shaka.extern.AbrManager.Factory} abrFactory
  390.    */
  391.   attachAbrManager(abrManager, abrFactory) {
  392.     this.abrManager_ = abrManager;
  393.     this.abrManagerFactory_ = abrFactory;
  394.   }
  396.   /**
  397.    * @param {?shaka.media.AdaptationSetCriteria} adaptationSetCriteria
  398.    */
  399.   attachAdaptationSetCriteria(adaptationSetCriteria) {
  400.     this.currentAdaptationSetCriteria_ = adaptationSetCriteria;
  401.   }
  403.   /**
  404.    * @param {!shaka.extern.Manifest} manifest
  405.    * @param {!shaka.extern.ManifestParser} parser
  406.    * @param {!shaka.extern.ManifestParser.Factory} parserFactory
  407.    */
  408.   attachManifest(manifest, parser, parserFactory) {
  409.     this.manifest_ = manifest;
  410.     this.parser_ = parser;
  411.     this.parserFactory_ = parserFactory;
  412.   }
  414.   /**
  415.    * Starts the process of loading the asset.
  416.    * Success or failure will be measured through waitForFinish()
  417.    */
  418.   start() {
  419.     (async () => {
  420.       // Force a context switch, to give the player a chance to hook up events
  421.       // immediately if desired.
  422.       await Promise.resolve();
  424.       // Perform the preloading process.
  425.       try {
  426.         await this.parseManifestInner_();
  427.         this.throwIfDestroyed_();
  429.         if (!shaka.drm.DrmUtils.isMediaKeysPolyfilled('webkit')) {
  430.           await this.initializeDrm();
  431.           this.throwIfDestroyed_();
  432.         }
  434.         await this.chooseInitialVariantAndPrefetchInner_();
  435.         this.throwIfDestroyed_();
  437.         // We don't need the drm keys to load completely for the initial variant
  438.         // to be chosen, but we won't mark the load as a success until it has
  439.         // been loaded. So wait for it here, not inside initializeDrmInner_.
  440.         if (this.allowPrefetch_ && this.drmEngine_) {
  441.           await this.drmEngine_.waitForActiveRequests();
  442.           this.throwIfDestroyed_();
  443.         }
  445.         this.successPromise_.resolve();
  446.       } catch (error) {
  447.         // Ignore OPERATION_ABORTED and OBJECT_DESTROYED errors.
  448.         if (!(error instanceof shaka.util.Error) ||
  449.             (error.code != shaka.util.Error.Code.OPERATION_ABORTED &&
  450.              error.code != shaka.util.Error.Code.OBJECT_DESTROYED)) {
  451.           this.successPromise_.reject(error);
  452.         }
  453.       }
  454.     })();
  455.   }
  457.   /**
  458.    * @param {!Event} event
  459.    * @return {boolean}
  460.    * @override
  461.    */
  462.   dispatchEvent(event) {
  463.     if (this.eventHandoffTarget_) {
  464.       return this.eventHandoffTarget_.dispatchEvent(event);
  465.     } else {
  466.       return super.dispatchEvent(event);
  467.     }
  468.   }
  470.   /**
  471.    * @param {!shaka.util.Error} error
  472.    */
  473.   onError(error) {
  474.     if (error.severity === shaka.util.Error.Severity.CRITICAL) {
  475.       // Cancel the loading process.
  476.       this.successPromise_.reject(error);
  477.       this.destroy();
  478.     }
  480.     const eventName = shaka.util.FakeEvent.EventName.Error;
  481.     const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
  482.     this.dispatchEvent(event);
  483.     if (event.defaultPrevented) {
  484.       error.handled = true;
  485.     }
  486.   }
  488.   /**
  489.    * Throw if destroyed, to interrupt processes with a recognizable error.
  490.    *
  491.    * @private
  492.    */
  493.   throwIfDestroyed_() {
  494.     if (this.isDestroyed()) {
  495.       throw new shaka.util.Error(
  496.           shaka.util.Error.Severity.CRITICAL,
  497.           shaka.util.Error.Category.PLAYER,
  498.           shaka.util.Error.Code.OBJECT_DESTROYED);
  499.     }
  500.   }
  502.   /**
  503.    * Makes a fires an event corresponding to entering a state of the loading
  504.    * process.
  505.    * @param {string} nodeName
  506.    * @private
  507.    */
  508.   makeStateChangeEvent_(nodeName) {
  509.     this.dispatchEvent(new shaka.util.FakeEvent(
  510.         /* name= */ shaka.util.FakeEvent.EventName.OnStateChange,
  511.         /* data= */ (new Map()).set('state', nodeName)));
  512.   }
  514.   /**
  515.    * @param {!shaka.util.FakeEvent.EventName} name
  516.    * @param {Map<string, Object>=} data
  517.    * @return {!shaka.util.FakeEvent}
  518.    * @private
  519.    */
  520.   makeEvent_(name, data) {
  521.     return new shaka.util.FakeEvent(name, data);
  522.   }
  524.   /**
  525.    * Pick and initialize a manifest parser, then have it download and parse the
  526.    * manifest.
  527.    *
  528.    * @return {!Promise}
  529.    * @private
  530.    */
  531.   async parseManifestInner_() {
  532.     this.makeStateChangeEvent_('manifest-parser');
  534.     if (!this.parser_) {
  535.       // Create the parser that we will use to parse the manifest.
  536.       this.parserFactory_ = shaka.media.ManifestParser.getFactory(
  537.           this.assetUri_, this.mimeType_);
  538.       goog.asserts.assert(this.parserFactory_, 'Must have manifest parser');
  539.       this.parser_ = this.parserFactory_();
  541.       this.parser_.configure(this.config_.manifest, () => this.isPreload_);
  542.     }
  544.     const startTime = Date.now() / 1000;
  546.     this.makeStateChangeEvent_('manifest');
  548.     if (!this.manifest_) {
  549.       this.manifest_ = await this.parser_.start(
  550.           this.assetUri_, this.manifestPlayerInterface_);
  552.       if (this.manifest_.variants.length == 1) {
  553.         const createSegmentIndexPromises = [];
  554.         const variant = this.manifest_.variants[0];
  555.         for (const stream of [variant.video, variant.audio]) {
  556.           if (stream && !stream.segmentIndex) {
  557.             createSegmentIndexPromises.push(stream.createSegmentIndex());
  558.           }
  559.         }
  560.         if (createSegmentIndexPromises.length > 0) {
  561.           await Promise.all(createSegmentIndexPromises);
  562.         }
  563.       }
  564.     }
  566.     this.manifestPromise_.resolve();
  568.     // This event is fired after the manifest is parsed, but before any
  569.     // filtering takes place.
  570.     const event =
  571.           this.makeEvent_(shaka.util.FakeEvent.EventName.ManifestParsed);
  572.     // Delay event to ensure manifest has been properly propagated
  573.     // to the player.
  574.     await Promise.resolve();
  575.     this.dispatchEvent(event);
  577.     // We require all manifests to have at least one variant.
  578.     if (this.manifest_.variants.length == 0) {
  579.       throw new shaka.util.Error(
  580.           shaka.util.Error.Severity.CRITICAL,
  581.           shaka.util.Error.Category.MANIFEST,
  582.           shaka.util.Error.Code.NO_VARIANTS);
  583.     }
  585.     // Make sure that all variants are either: audio-only, video-only, or
  586.     // audio-video.
  587.     shaka.media.PreloadManager.filterForAVVariants_(this.manifest_);
  589.     const now = Date.now() / 1000;
  590.     const delta = now - startTime;
  591.     this.stats_.setManifestTime(delta);
  592.   }
  594.   /**
  595.    * Initializes the DRM engine.
  596.    * @param {?HTMLMediaElement=} media
  597.    * @return {!Promise}
  598.    */
  599.   async initializeDrm(media) {
  600.     if (!this.manifest_ || this.drmEngine_) {
  601.       return;
  602.     }
  604.     this.makeStateChangeEvent_('drm-engine');
  606.     this.startTimeOfDrm_ = Date.now() / 1000;
  608.     this.drmEngine_ = this.createDrmEngine_();
  609.     this.manifestFilterer_.setDrmEngine(this.drmEngine_);
  611.     this.drmEngine_.configure(this.config_.drm, () => this.isPreload_);
  613.     const tracksChangedInitial = this.manifestFilterer_.applyRestrictions(
  614.         this.manifest_);
  615.     if (tracksChangedInitial) {
  616.       const event = this.makeEvent_(
  617.           shaka.util.FakeEvent.EventName.TracksChanged);
  618.       await Promise.resolve();
  619.       this.throwIfDestroyed_();
  620.       this.dispatchEvent(event);
  621.     }
  623.     const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
  624.         this.manifest_.variants);
  625.     let isLive = true;
  626.     // In HLS we need to parse the media playlist to know if it is Live or not.
  627.     // So at this point we don't know yet. By default we assume it is Live.
  628.     if (this.manifest_ && this.manifest_.presentationTimeline &&
  629.         this.manifest_.type != shaka.media.ManifestParser.HLS) {
  630.       isLive = this.manifest_.presentationTimeline.isLive();
  631.     }
  632.     await this.drmEngine_.initForPlayback(
  633.         playableVariants,
  634.         this.manifest_.offlineSessionIds,
  635.         isLive);
  636.     this.throwIfDestroyed_();
  637.     if (media) {
  638.       await this.drmEngine_.attach(media);
  639.       this.throwIfDestroyed_();
  640.     }
  642.     // Now that we have drm information, filter the manifest (again) so that
  643.     // we can ensure we only use variants with the selected key system.
  644.     const tracksChangedAfter = await this.manifestFilterer_.filterManifest(
  645.         this.manifest_);
  646.     if (tracksChangedAfter) {
  647.       const event = this.makeEvent_(
  648.           shaka.util.FakeEvent.EventName.TracksChanged);
  649.       await Promise.resolve();
  650.       this.dispatchEvent(event);
  651.     }
  652.   }
  654.   /** @param {!shaka.extern.PlayerConfiguration} config */
  655.   reconfigure(config) {
  656.     this.config_ = config;
  657.   }
  659.   /**
  660.    * @param {string} name
  661.    * @param {*=} value
  662.    */
  663.   configure(name, value) {
  664.     const config = shaka.util.ConfigUtils.convertToConfigObject(name, value);
  665.     shaka.util.PlayerConfiguration.mergeConfigObjects(this.config_, config);
  666.   }
  668.   /**
  669.    * Return a copy of the current configuration.
  670.    *
  671.    * @return {shaka.extern.PlayerConfiguration}
  672.    */
  673.   getConfiguration() {
  674.     return shaka.util.ObjectUtils.cloneObject(this.config_);
  675.   }
  677.   /**
  678.    * Performs a final filtering of the manifest, and chooses the initial
  679.    * variant. Also prefetches segments.
  680.    *
  681.    * @return {!Promise}
  682.    * @private
  683.    */
  684.   async chooseInitialVariantAndPrefetchInner_() {
  685.     goog.asserts.assert(
  686.         this.manifest_, 'The manifest should already be parsed.');
  688.     // This step does not have any associated events, as it is only part of the
  689.     // "load" state in the old state graph.
  691.     if (!this.currentAdaptationSetCriteria_) {
  692.       // Copy preferred languages from the config again, in case the config was
  693.       // changed between construction and playback.
  694.       this.currentAdaptationSetCriteria_ =
  695.           this.config_.adaptationSetCriteriaFactory();
  696.       this.currentAdaptationSetCriteria_.configure({
  697.         language: this.config_.preferredAudioLanguage,
  698.         role: this.config_.preferredVariantRole,
  699.         channelCount: this.config_.preferredAudioChannelCount,
  700.         hdrLevel: this.config_.preferredVideoHdrLevel,
  701.         spatialAudio: this.config_.preferSpatialAudio,
  702.         videoLayout: this.config_.preferredVideoLayout,
  703.         audioLabel: this.config_.preferredAudioLabel,
  704.         videoLabel: this.config_.preferredVideoLabel,
  705.         codecSwitchingStrategy:
  706.             this.config_.mediaSource.codecSwitchingStrategy,
  707.         audioCodec: '',
  708.       });
  709.     }
  711.     // Make the ABR manager.
  712.     if (this.allowMakeAbrManager_) {
  713.       const abrFactory = this.config_.abrFactory;
  714.       this.abrManagerFactory_ = abrFactory;
  715.       this.abrManager_ = abrFactory();
  716.       this.abrManager_.configure(this.config_.abr);
  717.     }
  719.     if (this.allowPrefetch_) {
  720.       const isLive = this.manifest_.presentationTimeline.isLive();
  721.       // Prefetch segments for the predicted first variant.
  722.       // We start these here, but don't wait for them; it's okay to start the
  723.       // full load process while the segments are being prefetched.
  724.       const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
  725.           this.manifest_.variants);
  726.       const adaptationSet = this.currentAdaptationSetCriteria_.create(
  727.           playableVariants);
  728.       // Guess what the first variant will be, based on a SimpleAbrManager.
  729.       this.abrManager_.configure(this.config_.abr);
  730.       this.abrManager_.setVariants(Array.from(adaptationSet.values()));
  731.       const variant = this.abrManager_.chooseVariant();
  732.       if (variant) {
  733.         const promises = [];
  734.         this.prefetchedVariant_ = variant;
  735.         if (variant.video) {
  736.           promises.push(this.prefetchStream_(variant.video, isLive));
  737.         }
  738.         if (variant.audio) {
  739.           promises.push(this.prefetchStream_(variant.audio, isLive));
  740.         }
  741.         const textStream = this.chooseTextStream_();
  742.         if (textStream && shaka.util.StreamUtils.shouldInitiallyShowText(
  743.             variant.audio, textStream, this.config_)) {
  744.           promises.push(this.prefetchStream_(textStream, isLive));
  745.           this.prefetchedTextStream_ = textStream;
  746.         }
  748.         await Promise.all(promises);
  749.       }
  750.     }
  751.   }
  753.   /**
  754.    * @return {?shaka.extern.Stream}
  755.    * @private
  756.    */
  757.   chooseTextStream_() {
  758.     const subset = shaka.util.StreamUtils.filterStreamsByLanguageAndRole(
  759.         this.manifest_.textStreams,
  760.         this.config_.preferredTextLanguage,
  761.         this.config_.preferredTextRole,
  762.         this.config_.preferForcedSubs);
  763.     return subset[0] || null;
  764.   }
  766.   /**
  767.    * @param {!shaka.extern.Stream} stream
  768.    * @param {boolean} isLive
  769.    * @return {!Promise}
  770.    * @private
  771.    */
  772.   async prefetchStream_(stream, isLive) {
  773.     // Use the prefetch limit from the config if this is set, otherwise use 2.
  774.     const prefetchLimit = this.config_.streaming.segmentPrefetchLimit || 2;
  775.     const prefetch = new shaka.media.SegmentPrefetch(
  776.         prefetchLimit, stream, (reference, stream, streamDataCallback) => {
  777.           return shaka.media.StreamingEngine.dispatchFetch(
  778.               reference, stream, streamDataCallback || null,
  779.               this.config_.streaming.retryParameters, this.networkingEngine_,
  780.               this.isPreload_);
  781.         }, /* reverse= */ false);
  782.     this.segmentPrefetchById_.set(stream.id, prefetch);
  784.     // Start prefetching a bit.
  785.     if (!stream.segmentIndex) {
  786.       await stream.createSegmentIndex();
  787.     }
  788.     const startTime = this.startTime_ || 0;
  789.     const prefetchSegmentIterator =
  790.         stream.segmentIndex.getIteratorForTime(startTime);
  791.     let prefetchSegment =
  792.         prefetchSegmentIterator ? prefetchSegmentIterator.current() : null;
  793.     if (!prefetchSegment) {
  794.       // If we can't get a segment at the desired spot, at least get a segment,
  795.       // so we can get the init segment.
  796.       prefetchSegment = stream.segmentIndex.earliestReference();
  797.     }
  798.     if (prefetchSegment) {
  799.       if (isLive) {
  800.         // Preload only the init segment for Live
  801.         if (prefetchSegment.initSegmentReference) {
  802.           await prefetch.prefetchInitSegment(
  803.               prefetchSegment.initSegmentReference);
  804.         }
  805.       } else {
  806.         // Preload a segment, too... either the first segment, or the segment
  807.         // that corresponds with this.startTime_, as appropriate.
  808.         // Note: this method also preload the init segment
  809.         await prefetch.prefetchSegmentsByTime(prefetchSegment.startTime);
  810.       }
  811.     }
  812.   }
  814.   /**
  815.    * Waits for the loading to be finished (or to fail with an error).
  816.    * @return {!Promise}
  817.    * @export
  818.    */
  819.   waitForFinish() {
  820.     return this.successPromise_;
  821.   }
  823.   /**
  824.    * Waits for the manifest to be loaded (or to fail with an error).
  825.    * @return {!Promise}
  826.    */
  827.   waitForManifest() {
  828.     const promises = [
  829.       this.manifestPromise_,
  830.       this.successPromise_,
  831.     ];
  832.     return Promise.race(promises);
  833.   }
  835.   /**
  836.    * Releases or stops all non-entrusted resources.
  837.    *
  838.    * @override
  839.    * @export
  840.    */
  841.   async destroy() {
  842.     this.destroyed_ = true;
  843.     if (this.parser_ && !this.parserEntrusted_) {
  844.       await this.parser_.stop();
  845.     }
  846.     if (this.abrManager_ && !this.abrManagerEntrusted_) {
  847.       await this.abrManager_.stop();
  848.     }
  849.     if (this.regionTimeline_ && !this.regionTimelineEntrusted_) {
  850.       this.regionTimeline_.release();
  851.     }
  852.     if (this.drmEngine_ && !this.drmEngineEntrusted_) {
  853.       await this.drmEngine_.destroy();
  854.     }
  855.     if (this.segmentPrefetchById_.size > 0 && !this.segmentPrefetchEntrusted_) {
  856.       for (const segmentPrefetch of this.segmentPrefetchById_.values()) {
  857.         segmentPrefetch.clearAll();
  858.       }
  859.     }
  860.     // this.eventHandoffTarget_ is not unset, so that events and errors fired
  861.     // after the preload manager is destroyed will still be routed to the
  862.     // player, if it was once linked up.
  863.   }
  865.   /** @return {boolean} */
  866.   isDestroyed() {
  867.     return this.destroyed_;
  868.   }
  870.   /** @return {boolean} */
  871.   hasBeenAttached() {
  872.     return this.hasBeenAttached_;
  873.   }
  875.   /**
  876.    * Take a series of variants and ensure that they only contain one type of
  877.    * variant. The different options are:
  878.    *  1. Audio-Video
  879.    *  2. Audio-Only
  880.    *  3. Video-Only
  881.    *
  882.    * A manifest can only contain a single type because once we initialize media
  883.    * source to expect specific streams, it must always have content for those
  884.    * streams. If we were to start with audio+video and switch to an audio-only
  885.    * variant, media source would block waiting for video content.
  886.    *
  887.    * @param {shaka.extern.Manifest} manifest
  888.    * @private
  889.    */
  890.   static filterForAVVariants_(manifest) {
  891.     const isAVVariant = (variant) => {
  892.       // Audio-video variants may include both streams separately or may be
  893.       // single multiplexed streams with multiple codecs.
  894.       return (variant.video && variant.audio) ||
  895.              (variant.video && variant.video.codecs.includes(','));
  896.     };
  897.     if (manifest.variants.some(isAVVariant)) {
  898.       shaka.log.debug('Found variant with audio and video content, ' +
  899.           'so filtering out audio-only content.');
  900.       manifest.variants = manifest.variants.filter(isAVVariant);
  901.     }
  902.   }
  903. };
  905. /**
  906.  * @typedef {{
  907.  *   config: !shaka.extern.PlayerConfiguration,
  908.  *   manifestPlayerInterface: !shaka.extern.ManifestParser.PlayerInterface,
  909.  *   regionTimeline: !shaka.media.RegionTimeline<
  910.  *       shaka.extern.TimelineRegionInfo>,
  911.  *   qualityObserver: ?shaka.media.QualityObserver,
  912.  *   createDrmEngine: function():!shaka.drm.DrmEngine,
  913.  *   networkingEngine: !shaka.net.NetworkingEngine,
  914.  *   manifestFilterer: !shaka.media.ManifestFilterer,
  915.  *   allowPrefetch: boolean,
  916.  *   allowMakeAbrManager: boolean
  917.  * }}
  918.  *
  919.  * @property {!shaka.extern.PlayerConfiguration} config
  920.  * @property {!shaka.extern.ManifestParser.PlayerInterface
  921.  *           } manifestPlayerInterface
  922.  * @property {!shaka.media.RegionTimeline<shaka.extern.TimelineRegionInfo>
  923.  *           } regionTimeline
  924.  * @property {?shaka.media.QualityObserver} qualityObserver
  925.  * @property {function():!shaka.drm.DrmEngine} createDrmEngine
  926.  * @property {!shaka.net.NetworkingEngine} networkingEngine
  927.  * @property {!shaka.media.ManifestFilterer} manifestFilterer
  928.  * @property {boolean} allowPrefetch
  929.  * @property {boolean} allowMakeAbrManager
  930.  */
  931. shaka.media.PreloadManager.PlayerInterface;