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.    * @param {shaka.extern.RequestContext=} context
  97.    *     A reference to the request context
  98.    * @exportDoc
  99.    */
  100.   segmentDownloaded(deltaTimeMs, numBytes, allowSwitch, request, context) {}
  102.   /**
  103.    * Notifies the ABR that it is a time to suggest new streams. This is used by
  104.    * the Player when it finishes adding the last partial segment of a fast
  105.    * switching stream.
  106.    *
  107.    * @exportDoc
  108.    */
  109.   trySuggestStreams() {}
  111.   /**
  112.    * Gets an estimate of the current bandwidth in bit/sec.  This is used by the
  113.    * Player to generate stats.
  114.    *
  115.    * @return {number}
  116.    * @exportDoc
  117.    */
  118.   getBandwidthEstimate() {}
  120.   /**
  121.    * Updates manager playback rate.
  122.    *
  123.    * @param {number} rate
  124.    * @exportDoc
  125.    */
  126.   playbackRateChanged(rate) {}
  128.   /**
  129.    * Set media element.
  130.    *
  131.    * @param {HTMLMediaElement} mediaElement
  132.    * @exportDoc
  133.    */
  134.   setMediaElement(mediaElement) {}
  136.   /**
  137.    * Set CMSD manager.
  138.    *
  139.    * @param {shaka.util.CmsdManager} cmsdManager
  140.    * @exportDoc
  141.    */
  142.   setCmsdManager(cmsdManager) {}
  144.   /**
  145.    * Sets the ABR configuration.
  146.    *
  147.    * It is the responsibility of the AbrManager implementation to implement the
  148.    * restrictions behavior described in shaka.extern.AbrConfiguration.
  149.    *
  150.    * @param {shaka.extern.AbrConfiguration} config
  151.    * @exportDoc
  152.    */
  153.   configure(config) {}
  154. };
  157. /**
  158.  * A callback into the Player that should be called when the AbrManager decides
  159.  * it's time to change to a different variant.
  160.  *
  161.  * The first argument is a variant to switch to.
  162.  *
  163.  * The second argument is an optional boolean. If true, all data will be removed
  164.  * from the buffer, which will result in a buffering event. Unless a third
  165.  * argument is passed.
  166.  *
  167.  * The third argument in an optional number that specifies how much data (in
  168.  * seconds) should be retained when clearing the buffer. This can help achieve
  169.  * a fast switch that doesn't involve a buffering event. A minimum of two video
  170.  * segments should always be kept buffered to avoid temporary hiccups.
  171.  *
  172.  * @typedef {function(shaka.extern.Variant, boolean=, number=)}
  173.  * @exportDoc
  174.  */
  175. shaka.extern.AbrManager.SwitchCallback;
  178. /**
  179.  * A factory for creating the abr manager.
  180.  *
  181.  * @typedef {function():!shaka.extern.AbrManager}
  182.  * @exportDoc
  183.  */
  184. shaka.extern.AbrManager.Factory;