Source: externs/shaka/abr_manager.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  8. /**
  9.  * @externs
  10.  */
  13. /**
  14.  * An object which selects Streams from a set of possible choices.  This also
  15.  * watches for system changes to automatically adapt for the current streaming
  16.  * requirements.  For example, when the network slows down, this class is in
  17.  * charge of telling the Player which streams to switch to in order to reduce
  18.  * the required bandwidth.
  19.  *
  20.  * This class is given a set of streams to choose from when the Player starts
  21.  * up.  This class should store these and use them to make future decisions
  22.  * about ABR.  It is up to this class how those decisions are made.  All the
  23.  * Player will do is tell this class what streams to choose from.
  24.  *
  25.  * @interface
  26.  * @exportDoc
  27.  */
  28. shaka.extern.AbrManager = class {
  29.   constructor() {}
  31.   /**
  32.    * Initializes the AbrManager.
  33.    *
  34.    * @param {shaka.extern.AbrManager.SwitchCallback} switchCallback
  35.    * @exportDoc
  36.    */
  37.   init(switchCallback) {}
  39.   /**
  40.    * Stops any background timers and frees any objects held by this instance.
  41.    * This will only be called after a call to init.
  42.    *
  43.    * @exportDoc
  44.    */
  45.   stop() {}
  47.   /**
  48.    * Request that this object release all internal references.
  49.    * @exportDoc
  50.    */
  51.   release() {}
  53.   /**
  54.    * Updates manager's variants collection.
  55.    *
  56.    * @param {!Array.<!shaka.extern.Variant>} variants
  57.    * @exportDoc
  58.    */
  59.   setVariants(variants) {}
  61.   /**
  62.    * Chooses one variant to switch to.  Called by the Player.
  63.    * @param {boolean=} preferFastSwitching If not provided meant "avoid fast
  64.    *                                       switching if possible".
  65.    * @return {shaka.extern.Variant}
  66.    * @exportDoc
  67.    */
  68.   chooseVariant(preferFastSwitching) {}
  70.   /**
  71.    * Enables automatic Variant choices from the last ones passed to setVariants.
  72.    * After this, the AbrManager may call switchCallback() at any time.
  73.    *
  74.    * @exportDoc
  75.    */
  76.   enable() {}
  78.   /**
  79.    * Disables automatic Stream suggestions. After this, the AbrManager may not
  80.    * call switchCallback().
  81.    *
  82.    * @exportDoc
  83.    */
  84.   disable() {}
  86.   /**
  87.    * Notifies the AbrManager that a segment has been downloaded (includes MP4
  88.    * SIDX data, WebM Cues data, initialization segments, and media segments).
  89.    *
  90.    * @param {number} deltaTimeMs The duration, in milliseconds, that the request
  91.    *     took to complete.
  92.    * @param {number} numBytes The total number of bytes transferred.
  93.    * @param {boolean} allowSwitch Indicate if the segment is allowed to switch
  94.    *     to another stream.
  95.    * @param {shaka.extern.Request=} request
  96.    *     A reference to the request
  97.    * @exportDoc
  98.    */
  99.   segmentDownloaded(deltaTimeMs, numBytes, allowSwitch, request) {}
  101.   /**
  102.    * Notifies the ABR that it is a time to suggest new streams. This is used by
  103.    * the Player when it finishes adding the last partial segment of a fast
  104.    * switching stream.
  105.    *
  106.    * @exportDoc
  107.    */
  108.   trySuggestStreams() {}
  110.   /**
  111.    * Gets an estimate of the current bandwidth in bit/sec.  This is used by the
  112.    * Player to generate stats.
  113.    *
  114.    * @return {number}
  115.    * @exportDoc
  116.    */
  117.   getBandwidthEstimate() {}
  119.   /**
  120.    * Updates manager playback rate.
  121.    *
  122.    * @param {number} rate
  123.    * @exportDoc
  124.    */
  125.   playbackRateChanged(rate) {}
  127.   /**
  128.    * Set media element.
  129.    *
  130.    * @param {HTMLMediaElement} mediaElement
  131.    * @exportDoc
  132.    */
  133.   setMediaElement(mediaElement) {}
  135.   /**
  136.    * Set CMSD manager.
  137.    *
  138.    * @param {shaka.util.CmsdManager} cmsdManager
  139.    * @exportDoc
  140.    */
  141.   setCmsdManager(cmsdManager) {}
  143.   /**
  144.    * Sets the ABR configuration.
  145.    *
  146.    * It is the responsibility of the AbrManager implementation to implement the
  147.    * restrictions behavior described in shaka.extern.AbrConfiguration.
  148.    *
  149.    * @param {shaka.extern.AbrConfiguration} config
  150.    * @exportDoc
  151.    */
  152.   configure(config) {}
  153. };
  156. /**
  157.  * A callback into the Player that should be called when the AbrManager decides
  158.  * it's time to change to a different variant.
  159.  *
  160.  * The first argument is a variant to switch to.
  161.  *
  162.  * The second argument is an optional boolean. If true, all data will be removed
  163.  * from the buffer, which will result in a buffering event. Unless a third
  164.  * argument is passed.
  165.  *
  166.  * The third argument in an optional number that specifies how much data (in
  167.  * seconds) should be retained when clearing the buffer. This can help achieve
  168.  * a fast switch that doesn't involve a buffering event. A minimum of two video
  169.  * segments should always be kept buffered to avoid temporary hiccups.
  170.  *
  171.  * @typedef {function(shaka.extern.Variant, boolean=, number=)}
  172.  * @exportDoc
  173.  */
  174. shaka.extern.AbrManager.SwitchCallback;
  177. /**
  178.  * A factory for creating the abr manager.
  179.  *
  180.  * @typedef {function():!shaka.extern.AbrManager}
  181.  * @exportDoc
  182.  */
  183. shaka.extern.AbrManager.Factory;