# All files / src/utils ewma-bandwidth-estimator.ts

100% Statements 18/18
100% Branches 4/4
80% Functions 4/5
100% Lines 18/18

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62

    30x
    5x
    5x
    5x
    5x
    5x
    5x

    9x
    9x

    9x

    9x
    9x
    9x

    10x
    10x

    10x

    9x

    1x

     /*
     * EWMA Bandwidth Estimator
     *  - heavily inspired from shaka-player
     * Tracks bandwidth samples and estimates available bandwidth.
     * Based on the minimum of two exponentially-weighted moving averages with
     * different half-lives.
     */

    import EWMA from '../utils/ewma';

    class EwmaBandWidthEstimator {
      hls: any;

      private defaultEstimate_: number;
      private minWeight_: number;
      private minDelayMs_: number;
      private slow_: EWMA;
      private fast_: EWMA;

      // TODO(typescript-hls)
      constructor (hls: any, slow: number, fast: number, defaultEstimate: number) {
        this.hls = hls;
        this.defaultEstimate_ = defaultEstimate;
        this.minWeight_ = 0.001;
        this.minDelayMs_ = 50;
        this.slow_ = new EWMA(slow);
        this.fast_ = new EWMA(fast);
      }

      sample (durationMs: number, numBytes: number) {
        durationMs = Math.max(durationMs, this.minDelayMs_);
        let numBits = 8 * numBytes,
          // weight is duration in seconds
          durationS = durationMs / 1000,
          // value is bandwidth in bits/s
          bandwidthInBps = numBits / durationS;
        this.fast_.sample(durationS, bandwidthInBps);
        this.slow_.sample(durationS, bandwidthInBps);
      }

      canEstimate (): boolean {
        let fast = this.fast_;
        return (fast && fast.getTotalWeight() >= this.minWeight_);
      }

      getEstimate (): number {
        if (this.canEstimate()) {
          // console.log('slow estimate:'+ Math.round(this.slow_.getEstimate()));
          // console.log('fast estimate:'+ Math.round(this.fast_.getEstimate()));
          // Take the minimum of these two estimates.  This should have the effect of
          // adapting down quickly, but up more slowly.
          return Math.min(this.fast_.getEstimate(), this.slow_.getEstimate());
        } else {
          return this.defaultEstimate_;
        }
      }

      destroy () {
      }
    }
    export default EwmaBandWidthEstimator;