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|Date} 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|Date} */
  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.       if (typeof this.startTime_ === 'number') {
  218.         this.startTime_ += offset;
  219.       } else {
  220.         this.startTime_.setTime(this.startTime_.getTime() + offset * 1000);
  221.       }
  222.     }
  223.   }
  225.   /** @return {?number|Date} */
  226.   getStartTime() {
  227.     return this.startTime_;
  228.   }
  230.   /** @return {number} */
  231.   getStartTimeOfDRM() {
  232.     return this.startTimeOfDrm_;
  233.   }
  235.   /** @return {?string} */
  236.   getMimeType() {
  237.     return this.mimeType_;
  238.   }
  240.   /** @return {string} */
  241.   getAssetUri() {
  242.     return this.assetUri_;
  243.   }
  245.   /** @return {?shaka.extern.Manifest} */
  246.   getManifest() {
  247.     return this.manifest_;
  248.   }
  250.   /** @return {?shaka.extern.ManifestParser.Factory} */
  251.   getParserFactory() {
  252.     return this.parserFactory_;
  253.   }
  255.   /** @return {?shaka.media.AdaptationSetCriteria} */
  256.   getCurrentAdaptationSetCriteria() {
  257.     return this.currentAdaptationSetCriteria_;
  258.   }
  260.   /** @return {?shaka.extern.AbrManager.Factory} */
  261.   getAbrManagerFactory() {
  262.     return this.abrManagerFactory_;
  263.   }
  265.   /**
  266.    * Gets the abr manager, if it exists. Also marks that the abr manager should
  267.    * not be stopped if this manager is destroyed.
  268.    * @return {?shaka.extern.AbrManager}
  269.    */
  270.   receiveAbrManager() {
  271.     this.abrManagerEntrusted_ = true;
  272.     return this.abrManager_;
  273.   }
  275.   /**
  276.    * @return {?shaka.extern.AbrManager}
  277.    */
  278.   getAbrManager() {
  279.     return this.abrManager_;
  280.   }
  282.   /**
  283.    * Gets the parser, if it exists. Also marks that the parser should not be
  284.    * stopped if this manager is destroyed.
  285.    * @return {?shaka.extern.ManifestParser}
  286.    */
  287.   receiveParser() {
  288.     this.parserEntrusted_ = true;
  289.     return this.parser_;
  290.   }
  292.   /**
  293.    * @return {?shaka.extern.ManifestParser}
  294.    */
  295.   getParser() {
  296.     return this.parser_;
  297.   }
  299.   /**
  300.    * Gets the region timeline, if it exists. Also marks that the timeline should
  301.    * not be released if this manager is destroyed.
  302.    * @return {?shaka.media.RegionTimeline<shaka.extern.TimelineRegionInfo>}
  303.    */
  304.   receiveRegionTimeline() {
  305.     this.regionTimelineEntrusted_ = true;
  306.     return this.regionTimeline_;
  307.   }
  309.   /**
  310.    * @return {?shaka.media.RegionTimeline<shaka.extern.TimelineRegionInfo>}
  311.    */
  312.   getRegionTimeline() {
  313.     return this.regionTimeline_;
  314.   }
  316.   /** @return {?shaka.media.QualityObserver} */
  317.   getQualityObserver() {
  318.     return this.qualityObserver_;
  319.   }
  321.   /** @return {!shaka.util.Stats} */
  322.   getStats() {
  323.     return this.stats_;
  324.   }
  326.   /** @return {!shaka.media.ManifestFilterer} */
  327.   getManifestFilterer() {
  328.     return this.manifestFilterer_;
  329.   }
  331.   /**
  332.    * Gets the drm engine, if it exists. Also marks that the drm engine should
  333.    * not be destroyed if this manager is destroyed.
  334.    * @return {?shaka.drm.DrmEngine}
  335.    */
  336.   receiveDrmEngine() {
  337.     this.drmEngineEntrusted_ = true;
  338.     return this.drmEngine_;
  339.   }
  341.   /**
  342.    * @return {?shaka.drm.DrmEngine}
  343.    */
  344.   getDrmEngine() {
  345.     return this.drmEngine_;
  346.   }
  348.   /**
  349.    * @return {?shaka.extern.Variant}
  350.    */
  351.   getPrefetchedVariant() {
  352.     return this.prefetchedVariant_;
  353.   }
  355.   /**
  356.    * Gets the preloaded variant track if it exists.
  357.    *
  358.    * @return {?shaka.extern.Track}
  359.    * @export
  360.    */
  361.   getPrefetchedVariantTrack() {
  362.     if (!this.prefetchedVariant_) {
  363.       return null;
  364.     }
  365.     return shaka.util.StreamUtils.variantToTrack(this.prefetchedVariant_);
  366.   }
  368.   /**
  369.    * Gets the preloaded text track if it exists.
  370.    *
  371.    * @return {?shaka.extern.TextTrack}
  372.    * @export
  373.    */
  374.   getPrefetchedTextTrack() {
  375.     if (!this.prefetchedTextStream_) {
  376.       return null;
  377.     }
  378.     return shaka.util.StreamUtils.textStreamToTrack(this.prefetchedTextStream_);
  379.   }
  381.   /**
  382.    * Gets the SegmentPrefetch objects for the initial stream ids. Also marks
  383.    * that those objects should not be aborted if this manager is destroyed.
  384.    * @return {!Map<number, shaka.media.SegmentPrefetch>}
  385.    */
  386.   receiveSegmentPrefetchesById() {
  387.     this.segmentPrefetchEntrusted_ = true;
  388.     return this.segmentPrefetchById_;
  389.   }
  391.   /**
  392.    * @param {?shaka.extern.AbrManager} abrManager
  393.    * @param {?shaka.extern.AbrManager.Factory} abrFactory
  394.    */
  395.   attachAbrManager(abrManager, abrFactory) {
  396.     this.abrManager_ = abrManager;
  397.     this.abrManagerFactory_ = abrFactory;
  398.   }
  400.   /**
  401.    * @param {?shaka.media.AdaptationSetCriteria} adaptationSetCriteria
  402.    */
  403.   attachAdaptationSetCriteria(adaptationSetCriteria) {
  404.     this.currentAdaptationSetCriteria_ = adaptationSetCriteria;
  405.   }
  407.   /**
  408.    * @param {!shaka.extern.Manifest} manifest
  409.    * @param {!shaka.extern.ManifestParser} parser
  410.    * @param {!shaka.extern.ManifestParser.Factory} parserFactory
  411.    */
  412.   attachManifest(manifest, parser, parserFactory) {
  413.     this.manifest_ = manifest;
  414.     this.parser_ = parser;
  415.     this.parserFactory_ = parserFactory;
  416.   }
  418.   /**
  419.    * Starts the process of loading the asset.
  420.    * Success or failure will be measured through waitForFinish()
  421.    */
  422.   start() {
  423.     (async () => {
  424.       // Force a context switch, to give the player a chance to hook up events
  425.       // immediately if desired.
  426.       await Promise.resolve();
  428.       // Perform the preloading process.
  429.       try {
  430.         await this.parseManifestInner_();
  431.         this.throwIfDestroyed_();
  433.         await this.chooseInitialVariant_();
  434.         this.throwIfDestroyed_();
  436.         if (!shaka.drm.DrmUtils.isMediaKeysPolyfilled('webkit')) {
  437.           await this.initializeDrm();
  438.           this.throwIfDestroyed_();
  439.         }
  441.         if (this.allowPrefetch_) {
  442.           await this.prefetchInner_();
  443.           this.throwIfDestroyed_();
  444.         }
  446.         // We don't need the drm keys to load completely for the initial variant
  447.         // to be chosen, but we won't mark the load as a success until it has
  448.         // been loaded. So wait for it here, not inside initializeDrmInner_.
  449.         if (this.allowPrefetch_ && this.drmEngine_) {
  450.           await this.drmEngine_.waitForActiveRequests();
  451.           this.throwIfDestroyed_();
  452.         }
  454.         this.successPromise_.resolve();
  455.       } catch (error) {
  456.         // Ignore OPERATION_ABORTED and OBJECT_DESTROYED errors.
  457.         if (!(error instanceof shaka.util.Error) ||
  458.             (error.code != shaka.util.Error.Code.OPERATION_ABORTED &&
  459.              error.code != shaka.util.Error.Code.OBJECT_DESTROYED)) {
  460.           this.successPromise_.reject(error);
  461.         }
  462.       }
  463.     })();
  464.   }
  466.   /**
  467.    * @param {!Event} event
  468.    * @return {boolean}
  469.    * @override
  470.    */
  471.   dispatchEvent(event) {
  472.     if (this.eventHandoffTarget_) {
  473.       return this.eventHandoffTarget_.dispatchEvent(event);
  474.     } else {
  475.       return super.dispatchEvent(event);
  476.     }
  477.   }
  479.   /**
  480.    * @param {!shaka.util.Error} error
  481.    */
  482.   onError(error) {
  483.     if (error.severity === shaka.util.Error.Severity.CRITICAL) {
  484.       // Cancel the loading process.
  485.       this.successPromise_.reject(error);
  486.       this.destroy();
  487.     }
  489.     const eventName = shaka.util.FakeEvent.EventName.Error;
  490.     const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
  491.     this.dispatchEvent(event);
  492.     if (event.defaultPrevented) {
  493.       error.handled = true;
  494.     }
  495.   }
  497.   /**
  498.    * Throw if destroyed, to interrupt processes with a recognizable error.
  499.    *
  500.    * @private
  501.    */
  502.   throwIfDestroyed_() {
  503.     if (this.isDestroyed()) {
  504.       throw new shaka.util.Error(
  505.           shaka.util.Error.Severity.CRITICAL,
  506.           shaka.util.Error.Category.PLAYER,
  507.           shaka.util.Error.Code.OBJECT_DESTROYED);
  508.     }
  509.   }
  511.   /**
  512.    * Makes a fires an event corresponding to entering a state of the loading
  513.    * process.
  514.    * @param {string} nodeName
  515.    * @private
  516.    */
  517.   makeStateChangeEvent_(nodeName) {
  518.     this.dispatchEvent(new shaka.util.FakeEvent(
  519.         /* name= */ shaka.util.FakeEvent.EventName.OnStateChange,
  520.         /* data= */ (new Map()).set('state', nodeName)));
  521.   }
  523.   /**
  524.    * @param {!shaka.util.FakeEvent.EventName} name
  525.    * @param {Map<string, Object>=} data
  526.    * @return {!shaka.util.FakeEvent}
  527.    * @private
  528.    */
  529.   makeEvent_(name, data) {
  530.     return new shaka.util.FakeEvent(name, data);
  531.   }
  533.   /**
  534.    * Pick and initialize a manifest parser, then have it download and parse the
  535.    * manifest.
  536.    *
  537.    * @return {!Promise}
  538.    * @private
  539.    */
  540.   async parseManifestInner_() {
  541.     this.makeStateChangeEvent_('manifest-parser');
  543.     if (!this.parser_) {
  544.       // Create the parser that we will use to parse the manifest.
  545.       this.parserFactory_ = shaka.media.ManifestParser.getFactory(
  546.           this.assetUri_, this.mimeType_);
  547.       goog.asserts.assert(this.parserFactory_, 'Must have manifest parser');
  548.       this.parser_ = this.parserFactory_();
  550.       this.parser_.configure(this.config_.manifest, () => this.isPreload_);
  551.     }
  553.     const startTime = Date.now() / 1000;
  555.     this.makeStateChangeEvent_('manifest');
  557.     if (!this.manifest_) {
  558.       this.manifest_ = await this.parser_.start(
  559.           this.assetUri_, this.manifestPlayerInterface_);
  560.     }
  562.     this.manifestPromise_.resolve();
  564.     // This event is fired after the manifest is parsed, but before any
  565.     // filtering takes place.
  566.     const event =
  567.           this.makeEvent_(shaka.util.FakeEvent.EventName.ManifestParsed);
  568.     // Delay event to ensure manifest has been properly propagated
  569.     // to the player.
  570.     await Promise.resolve();
  571.     this.dispatchEvent(event);
  573.     // We require all manifests to have at least one variant.
  574.     if (this.manifest_.variants.length == 0) {
  575.       throw new shaka.util.Error(
  576.           shaka.util.Error.Severity.CRITICAL,
  577.           shaka.util.Error.Category.MANIFEST,
  578.           shaka.util.Error.Code.NO_VARIANTS);
  579.     }
  581.     // Make sure that all variants are either: audio-only, video-only, or
  582.     // audio-video.
  583.     shaka.media.PreloadManager.filterForAVVariants_(this.manifest_);
  585.     const tracksChangedInitial = this.manifestFilterer_.applyRestrictions(
  586.         this.manifest_);
  587.     if (tracksChangedInitial) {
  588.       const event = this.makeEvent_(
  589.           shaka.util.FakeEvent.EventName.TracksChanged);
  590.       await Promise.resolve();
  591.       this.throwIfDestroyed_();
  592.       this.dispatchEvent(event);
  593.     }
  595.     const now = Date.now() / 1000;
  596.     const delta = now - startTime;
  597.     this.stats_.setManifestTime(delta);
  598.   }
  600.   /**
  601.    * Initializes the DRM engine.
  602.    * @param {?HTMLMediaElement=} media
  603.    * @return {!Promise}
  604.    */
  605.   async initializeDrm(media) {
  606.     if (!this.manifest_ || this.drmEngine_) {
  607.       return;
  608.     }
  610.     this.makeStateChangeEvent_('drm-engine');
  612.     this.startTimeOfDrm_ = Date.now() / 1000;
  614.     this.drmEngine_ = this.createDrmEngine_();
  615.     this.manifestFilterer_.setDrmEngine(this.drmEngine_);
  617.     this.drmEngine_.configure(this.config_.drm, () => this.isPreload_);
  619.     const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
  620.         this.manifest_.variants);
  621.     let isLive = true;
  622.     if (this.manifest_ && this.manifest_.presentationTimeline) {
  623.       isLive = this.manifest_.presentationTimeline.isLive();
  624.     }
  625.     await this.drmEngine_.initForPlayback(
  626.         playableVariants,
  627.         this.manifest_.offlineSessionIds,
  628.         isLive);
  629.     this.throwIfDestroyed_();
  630.     if (media) {
  631.       await this.drmEngine_.attach(media);
  632.       this.throwIfDestroyed_();
  633.     }
  635.     // Now that we have drm information, filter the manifest (again) so that
  636.     // we can ensure we only use variants with the selected key system.
  637.     const tracksChangedAfter = await this.manifestFilterer_.filterManifest(
  638.         this.manifest_);
  639.     if (tracksChangedAfter) {
  640.       const event = this.makeEvent_(
  641.           shaka.util.FakeEvent.EventName.TracksChanged);
  642.       await Promise.resolve();
  643.       this.dispatchEvent(event);
  644.     }
  645.   }
  647.   /** @param {!shaka.extern.PlayerConfiguration} config */
  648.   reconfigure(config) {
  649.     this.config_ = config;
  650.   }
  652.   /**
  653.    * @param {string} name
  654.    * @param {*=} value
  655.    */
  656.   configure(name, value) {
  657.     const config = shaka.util.ConfigUtils.convertToConfigObject(name, value);
  658.     shaka.util.PlayerConfiguration.mergeConfigObjects(this.config_, config);
  659.   }
  661.   /**
  662.    * Return a copy of the current configuration.
  663.    *
  664.    * @return {shaka.extern.PlayerConfiguration}
  665.    */
  666.   getConfiguration() {
  667.     return shaka.util.ObjectUtils.cloneObject(this.config_);
  668.   }
  670.   /**
  671.    * Performs a filtering of the manifest, and chooses the initial
  672.    * variant.
  673.    *
  674.    * @return {!Promise}
  675.    * @private
  676.    */
  677.   async chooseInitialVariant_() {
  678.     goog.asserts.assert(
  679.         this.manifest_, 'The manifest should already be parsed.');
  681.     // This step does not have any associated events, as it is only part of the
  682.     // "load" state in the old state graph.
  684.     if (!this.currentAdaptationSetCriteria_) {
  685.       // Copy preferred languages from the config again, in case the config was
  686.       // changed between construction and playback.
  687.       this.currentAdaptationSetCriteria_ =
  688.           this.config_.adaptationSetCriteriaFactory();
  689.       this.currentAdaptationSetCriteria_.configure({
  690.         language: this.config_.preferredAudioLanguage,
  691.         role: this.config_.preferredVariantRole,
  692.         channelCount: this.config_.preferredAudioChannelCount,
  693.         hdrLevel: this.config_.preferredVideoHdrLevel,
  694.         spatialAudio: this.config_.preferSpatialAudio,
  695.         videoLayout: this.config_.preferredVideoLayout,
  696.         audioLabel: this.config_.preferredAudioLabel,
  697.         videoLabel: this.config_.preferredVideoLabel,
  698.         codecSwitchingStrategy:
  699.             this.config_.mediaSource.codecSwitchingStrategy,
  700.         audioCodec: '',
  701.         activeAudioCodec: '',
  702.         activeAudioChannelCount: 0,
  703.         preferredAudioCodecs: this.config_.preferredAudioCodecs,
  704.         preferredAudioChannelCount: this.config_.preferredAudioChannelCount,
  705.       });
  706.     }
  708.     // Make the ABR manager.
  709.     if (this.allowMakeAbrManager_) {
  710.       const abrFactory = this.config_.abrFactory;
  711.       this.abrManagerFactory_ = abrFactory;
  712.       this.abrManager_ = abrFactory();
  713.       this.abrManager_.configure(this.config_.abr);
  714.     }
  716.     const variant = this.configureAbrManagerAndChooseVariant_();
  717.     if (variant &&
  718.         this.shouldCreateSegmentIndexBeforeDrmEngineInitialization_()) {
  719.       const createSegmentIndexPromises = [];
  720.       for (const stream of [variant.video, variant.audio]) {
  721.         if (stream && !stream.segmentIndex) {
  722.           createSegmentIndexPromises.push(stream.createSegmentIndex());
  723.         }
  724.       }
  725.       if (createSegmentIndexPromises.length > 0) {
  726.         await Promise.all(createSegmentIndexPromises);
  727.       }
  728.     }
  729.   }
  731.   /**
  732.    * @return {boolean}
  733.    * @private
  734.    */
  735.   shouldCreateSegmentIndexBeforeDrmEngineInitialization_() {
  736.     goog.asserts.assert(
  737.         this.manifest_, 'The manifest should already be parsed.');
  739.     // If we only have one variant, it is useful to preload it, because it will
  740.     // be the only one we can use.
  741.     if (this.manifest_.variants.length == 1) {
  742.       return true;
  743.     }
  745.     // In HLS, DRM information is usually included in the media playlist, so we
  746.     // need to download the media playlist to get the real information.
  747.     if (this.manifest_.type == shaka.media.ManifestParser.HLS) {
  748.       return true;
  749.     }
  751.     return false;
  752.   }
  754.   /**
  755.    * Prefetches segments.
  756.    *
  757.    * @return {!Promise}
  758.    * @private
  759.    */
  760.   async prefetchInner_() {
  761.     const variant = this.configureAbrManagerAndChooseVariant_();
  762.     if (variant) {
  763.       const isLive = this.manifest_.presentationTimeline.isLive();
  764.       const promises = [];
  765.       this.prefetchedVariant_ = variant;
  766.       if (variant.video) {
  767.         promises.push(this.prefetchStream_(variant.video, isLive));
  768.       }
  769.       if (variant.audio) {
  770.         promises.push(this.prefetchStream_(variant.audio, isLive));
  771.       }
  772.       const textStream = this.chooseTextStream_();
  773.       if (textStream && shaka.util.StreamUtils.shouldInitiallyShowText(
  774.           variant.audio, textStream, this.config_)) {
  775.         promises.push(this.prefetchStream_(textStream, isLive));
  776.         this.prefetchedTextStream_ = textStream;
  777.       }
  779.       await Promise.all(promises);
  780.     }
  781.   }
  783.   /**
  784.    * @return {shaka.extern.Variant}
  785.    * @private
  786.    */
  787.   configureAbrManagerAndChooseVariant_() {
  788.     goog.asserts.assert(this.currentAdaptationSetCriteria_,
  789.         'Must have an AdaptationSetCriteria');
  791.     const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
  792.         this.manifest_.variants);
  793.     const adaptationSet = this.currentAdaptationSetCriteria_.create(
  794.         playableVariants);
  795.     // Guess what the first variant will be, based on a SimpleAbrManager.
  796.     this.abrManager_.configure(this.config_.abr);
  797.     this.abrManager_.setVariants(Array.from(adaptationSet.values()));
  799.     return this.abrManager_.chooseVariant();
  800.   }
  802.   /**
  803.    * @return {?shaka.extern.Stream}
  804.    * @private
  805.    */
  806.   chooseTextStream_() {
  807.     const subset = shaka.util.StreamUtils.filterStreamsByLanguageAndRole(
  808.         this.manifest_.textStreams,
  809.         this.config_.preferredTextLanguage,
  810.         this.config_.preferredTextRole,
  811.         this.config_.preferForcedSubs);
  812.     return subset[0] || null;
  813.   }
  815.   /**
  816.    * @param {!shaka.extern.Stream} stream
  817.    * @param {boolean} isLive
  818.    * @return {!Promise}
  819.    * @private
  820.    */
  821.   async prefetchStream_(stream, isLive) {
  822.     // Use the prefetch limit from the config if this is set, otherwise use 2.
  823.     const prefetchLimit = this.config_.streaming.segmentPrefetchLimit || 2;
  824.     const prefetch = new shaka.media.SegmentPrefetch(
  825.         prefetchLimit, stream, (reference, stream, streamDataCallback) => {
  826.           return shaka.media.StreamingEngine.dispatchFetch(
  827.               reference, stream, streamDataCallback || null,
  828.               this.config_.streaming.retryParameters, this.networkingEngine_,
  829.               this.isPreload_);
  830.         }, /* reverse= */ false);
  831.     this.segmentPrefetchById_.set(stream.id, prefetch);
  833.     // Start prefetching a bit.
  834.     if (!stream.segmentIndex) {
  835.       await stream.createSegmentIndex();
  836.     }
  837.     // Ignore if start time is a Date, as we do not prefetch segments for live
  838.     // anyway.
  839.     const startTime = typeof this.startTime_ === 'number' ? this.startTime_ : 0;
  840.     const prefetchSegmentIterator =
  841.         stream.segmentIndex.getIteratorForTime(startTime);
  842.     let prefetchSegment = null;
  843.     if (prefetchSegmentIterator) {
  844.       prefetchSegment = prefetchSegmentIterator.current();
  845.       if (!prefetchSegment) {
  846.         prefetchSegment = prefetchSegmentIterator.next().value;
  847.       }
  848.     }
  849.     if (!prefetchSegment) {
  850.       // If we can't get a segment at the desired spot, at least get a segment,
  851.       // so we can get the init segment.
  852.       prefetchSegment = stream.segmentIndex.earliestReference();
  853.     }
  854.     if (prefetchSegment) {
  855.       if (isLive) {
  856.         // Preload only the init segment for Live
  857.         if (prefetchSegment.initSegmentReference) {
  858.           await prefetch.prefetchInitSegment(
  859.               prefetchSegment.initSegmentReference);
  860.         }
  861.       } else {
  862.         // Preload a segment, too... either the first segment, or the segment
  863.         // that corresponds with this.startTime_, as appropriate.
  864.         // Note: this method also preload the init segment
  865.         await prefetch.prefetchSegmentsByTime(prefetchSegment.startTime);
  866.       }
  867.     }
  868.   }
  870.   /**
  871.    * Waits for the loading to be finished (or to fail with an error).
  872.    * @return {!Promise}
  873.    * @export
  874.    */
  875.   waitForFinish() {
  876.     return this.successPromise_;
  877.   }
  879.   /**
  880.    * Waits for the manifest to be loaded (or to fail with an error).
  881.    * @return {!Promise}
  882.    */
  883.   waitForManifest() {
  884.     const promises = [
  885.       this.manifestPromise_,
  886.       this.successPromise_,
  887.     ];
  888.     return Promise.race(promises);
  889.   }
  891.   /**
  892.    * Releases or stops all non-entrusted resources.
  893.    *
  894.    * @override
  895.    * @export
  896.    */
  897.   async destroy() {
  898.     this.destroyed_ = true;
  899.     if (this.parser_ && !this.parserEntrusted_) {
  900.       await this.parser_.stop();
  901.     }
  902.     if (this.abrManager_ && !this.abrManagerEntrusted_) {
  903.       await this.abrManager_.stop();
  904.     }
  905.     if (this.regionTimeline_ && !this.regionTimelineEntrusted_) {
  906.       this.regionTimeline_.release();
  907.     }
  908.     if (this.drmEngine_ && !this.drmEngineEntrusted_) {
  909.       await this.drmEngine_.destroy();
  910.     }
  911.     if (this.segmentPrefetchById_.size > 0 && !this.segmentPrefetchEntrusted_) {
  912.       for (const segmentPrefetch of this.segmentPrefetchById_.values()) {
  913.         segmentPrefetch.clearAll();
  914.       }
  915.     }
  916.     // this.eventHandoffTarget_ is not unset, so that events and errors fired
  917.     // after the preload manager is destroyed will still be routed to the
  918.     // player, if it was once linked up.
  919.   }
  921.   /** @return {boolean} */
  922.   isDestroyed() {
  923.     return this.destroyed_;
  924.   }
  926.   /** @return {boolean} */
  927.   hasBeenAttached() {
  928.     return this.hasBeenAttached_;
  929.   }
  931.   /**
  932.    * Take a series of variants and ensure that they only contain one type of
  933.    * variant. The different options are:
  934.    *  1. Audio-Video
  935.    *  2. Audio-Only
  936.    *  3. Video-Only
  937.    *
  938.    * A manifest can only contain a single type because once we initialize media
  939.    * source to expect specific streams, it must always have content for those
  940.    * streams. If we were to start with audio+video and switch to an audio-only
  941.    * variant, media source would block waiting for video content.
  942.    *
  943.    * @param {shaka.extern.Manifest} manifest
  944.    * @private
  945.    */
  946.   static filterForAVVariants_(manifest) {
  947.     const isAVVariant = (variant) => {
  948.       // Audio-video variants may include both streams separately or may be
  949.       // single multiplexed streams with multiple codecs.
  950.       return (variant.video && variant.audio) ||
  951.              (variant.video && variant.video.codecs.includes(','));
  952.     };
  953.     if (manifest.variants.some(isAVVariant)) {
  954.       shaka.log.debug('Found variant with audio and video content, ' +
  955.           'so filtering out audio-only content.');
  956.       manifest.variants = manifest.variants.filter(isAVVariant);
  957.     }
  958.   }
  959. };
  961. /**
  962.  * @typedef {{
  963.  *   config: !shaka.extern.PlayerConfiguration,
  964.  *   manifestPlayerInterface: !shaka.extern.ManifestParser.PlayerInterface,
  965.  *   regionTimeline: !shaka.media.RegionTimeline<
  966.  *       shaka.extern.TimelineRegionInfo>,
  967.  *   qualityObserver: ?shaka.media.QualityObserver,
  968.  *   createDrmEngine: function():!shaka.drm.DrmEngine,
  969.  *   networkingEngine: !shaka.net.NetworkingEngine,
  970.  *   manifestFilterer: !shaka.media.ManifestFilterer,
  971.  *   allowPrefetch: boolean,
  972.  *   allowMakeAbrManager: boolean,
  973.  * }}
  974.  *
  975.  * @property {!shaka.extern.PlayerConfiguration} config
  976.  * @property {!shaka.extern.ManifestParser.PlayerInterface
  977.  *           } manifestPlayerInterface
  978.  * @property {!shaka.media.RegionTimeline<shaka.extern.TimelineRegionInfo>
  979.  *           } regionTimeline
  980.  * @property {?shaka.media.QualityObserver} qualityObserver
  981.  * @property {function():!shaka.drm.DrmEngine} createDrmEngine
  982.  * @property {!shaka.net.NetworkingEngine} networkingEngine
  983.  * @property {!shaka.media.ManifestFilterer} manifestFilterer
  984.  * @property {boolean} allowPrefetch
  985.  * @property {boolean} allowMakeAbrManager
  986.  */
  987. shaka.media.PreloadManager.PlayerInterface;