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.    *
  64.    * @return {shaka.extern.Variant}
  65.    * @exportDoc
  66.    */
  67.   chooseVariant() {}
  69.   /**
  70.    * Enables automatic Variant choices from the last ones passed to setVariants.
  71.    * After this, the AbrManager may call switchCallback() at any time.
  72.    *
  73.    * @exportDoc
  74.    */
  75.   enable() {}
  77.   /**
  78.    * Disables automatic Stream suggestions. After this, the AbrManager may not
  79.    * call switchCallback().
  80.    *
  81.    * @exportDoc
  82.    */
  83.   disable() {}
  85.   /**
  86.    * Notifies the AbrManager that a segment has been downloaded (includes MP4
  87.    * SIDX data, WebM Cues data, initialization segments, and media segments).
  88.    *
  89.    * @param {number} deltaTimeMs The duration, in milliseconds, that the request
  90.    *     took to complete.
  91.    * @param {number} numBytes The total number of bytes transferred.
  92.    * @param {boolean} allowSwitch Indicate if the segment is allowed to switch
  93.    *     to another stream.
  94.    * @param {shaka.extern.Request=} request
  95.    *     A reference to the request
  96.    * @exportDoc
  97.    */
  98.   segmentDownloaded(deltaTimeMs, numBytes, allowSwitch, request) {}
  100.   /**
  101.    * Notifies the ABR that it is a time to suggest new streams. This is used by
  102.    * the Player when it finishes adding the last partial segment of a fast
  103.    * switching stream.
  104.    *
  105.    * @exportDoc
  106.    */
  107.   trySuggestStreams() {}
  109.   /**
  110.    * Gets an estimate of the current bandwidth in bit/sec.  This is used by the
  111.    * Player to generate stats.
  112.    *
  113.    * @return {number}
  114.    * @exportDoc
  115.    */
  116.   getBandwidthEstimate() {}
  118.   /**
  119.    * Updates manager playback rate.
  120.    *
  121.    * @param {number} rate
  122.    * @exportDoc
  123.    */
  124.   playbackRateChanged(rate) {}
  126.   /**
  127.    * Set media element.
  128.    *
  129.    * @param {HTMLMediaElement} mediaElement
  130.    * @exportDoc
  131.    */
  132.   setMediaElement(mediaElement) {}
  134.   /**
  135.    * Set CMSD manager.
  136.    *
  137.    * @param {shaka.util.CmsdManager} cmsdManager
  138.    * @exportDoc
  139.    */
  140.   setCmsdManager(cmsdManager) {}
  142.   /**
  143.    * Sets the ABR configuration.
  144.    *
  145.    * It is the responsibility of the AbrManager implementation to implement the
  146.    * restrictions behavior described in shaka.extern.AbrConfiguration.
  147.    *
  148.    * @param {shaka.extern.AbrConfiguration} config
  149.    * @exportDoc
  150.    */
  151.   configure(config) {}
  152. };
  155. /**
  156.  * A callback into the Player that should be called when the AbrManager decides
  157.  * it's time to change to a different variant.
  158.  *
  159.  * The first argument is a variant to switch to.
  160.  *
  161.  * The second argument is an optional boolean. If true, all data will be removed
  162.  * from the buffer, which will result in a buffering event. Unless a third
  163.  * argument is passed.
  164.  *
  165.  * The third argument in an optional number that specifies how much data (in
  166.  * seconds) should be retained when clearing the buffer. This can help achieve
  167.  * a fast switch that doesn't involve a buffering event. A minimum of two video
  168.  * segments should always be kept buffered to avoid temporary hiccups.
  169.  *
  170.  * @typedef {function(shaka.extern.Variant, boolean=, number=)}
  171.  * @exportDoc
  172.  */
  173. shaka.extern.AbrManager.SwitchCallback;
  176. /**
  177.  * A factory for creating the abr manager.
  178.  *
  179.  * @typedef {function():!shaka.extern.AbrManager}
  180.  * @exportDoc
  181.  */
  182. shaka.extern.AbrManager.Factory;