shaka-player/lib/util/stats.js

/*! @license
 * Shaka Player
 * Copyright 2016 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

goog.provide('shaka.util.Stats');

goog.require('shaka.util.StateHistory');
goog.require('shaka.util.SwitchHistory');


/**
 * This class tracks all the various components (some optional) that are used to
 * populate |shaka.extern.Stats| which is passed to the app.
 *
 * @final
 */
shaka.util.Stats = class {
  constructor() {
    /** @private {number} */
    this.width_ = NaN;
    /** @private {number} */
    this.height_ = NaN;

    /** @private {string} */
    this.currentCodecs_ = '';

    /** @private {number} */
    this.totalDroppedFrames_ = NaN;
    /** @private {number} */
    this.totalDecodedFrames_ = NaN;
    /** @private {number} */
    this.totalCorruptedFrames_ = NaN;

    /** @private {number} */
    this.totalStallsDetected_ = NaN;
    /** @private {number} */
    this.totalGapsJumped_ = NaN;

    /** @private {number} */
    this.completionPercent_ = NaN;

    /** @private {number} */
    this.loadLatencySeconds_ = NaN;

    /** @private {number} */
    this.manifestTimeSeconds_ = NaN;

    /** @private {number} */
    this.drmTimeSeconds_ = NaN;

    /** @private {number} */
    this.licenseTimeSeconds_ = NaN;

    /** @private {number} */
    this.liveLatencySeconds_ = NaN;

    /** @private {number} */
    this.maxSegmentDurationSeconds_ = NaN;

    /** @private {number} */
    this.currentStreamBandwidth_ = NaN;
    /** @private {number} */
    this.bandwidthEstimate_ = NaN;

    /** @private {number} */
    this.manifestSizeBytes_ = NaN;
    /** @private {number} */
    this.bytesDownloaded_ = NaN;

    /** @private {number} */
    this.nonFatalErrorCount_ = 0;
    /** @private {number} */
    this.manifestPeriodCount_ = NaN;
    /** @private {number} */
    this.manifestGapCount_ = NaN;

    /** @private {!shaka.util.StateHistory} */
    this.stateHistory_ = new shaka.util.StateHistory();

    /** @private {!shaka.util.SwitchHistory} */
    this.switchHistory_ = new shaka.util.SwitchHistory();
  }

  /**
   * Update the ratio of dropped frames to total frames. This will replace the
   * previous values.
   *
   * @param {number} dropped
   * @param {number} decoded
   */
  setDroppedFrames(dropped, decoded) {
    this.totalDroppedFrames_ = dropped;
    this.totalDecodedFrames_ = decoded;
  }

  /**
   * Update corrupted frames. This will replace the previous values.
   *
   * @param {number} corrupted
   */
  setCorruptedFrames(corrupted) {
    this.totalCorruptedFrames_ = corrupted;
  }

  /**
   * Update number of stalls detected. This will replace the previous value.
   *
   * @param {number} stallsDetected
   */
  setStallsDetected(stallsDetected) {
    this.totalStallsDetected_ = stallsDetected;
  }

  /**
   * Update number of playback gaps jumped over. This will replace the previous
   * value.
   *
   * @param {number} gapsJumped
   */
  setGapsJumped(gapsJumped) {
    this.totalGapsJumped_ = gapsJumped;
  }

  /**
   * Set the width and height of the video we are currently playing.
   *
   * @param {number} width
   * @param {number} height
   */
  setResolution(width, height) {
    this.width_ = width;
    this.height_ = height;
  }

  /**
   * Set the codecs that we are currently playing.
   *
   * @param {string} codecs
   */
  setCodecs(codecs) {
    this.currentCodecs_ = codecs;
  }

  /**
   * Record the time it took between the user signalling "I want to play this"
   * to "I am now seeing this".
   *
   * @param {number} seconds
   */
  setLoadLatency(seconds) {
    this.loadLatencySeconds_ = seconds;
  }

  /**
   * Record the time it took to download and parse the manifest.
   *
   * @param {number} seconds
   */
  setManifestTime(seconds) {
    this.manifestTimeSeconds_ = seconds;
  }

  /**
   * Record the current completion percent. This is the "high water mark", so it
   * will store the highest provided completion percent.
   *
   * @param {number} percent
   */
  setCompletionPercent(percent) {
    if (isNaN(this.completionPercent_)) {
      this.completionPercent_ = percent;
    } else {
      this.completionPercent_ = Math.max(this.completionPercent_, percent);
    }
  }

  /**
   * Record the time it took to download the first drm key.
   *
   * @param {number} seconds
   */
  setDrmTime(seconds) {
    this.drmTimeSeconds_ = seconds;
  }

  /**
   * Record the cumulative time spent on license requests during this session.
   *
   * @param {number} seconds
   */
  setLicenseTime(seconds) {
    this.licenseTimeSeconds_ = seconds;
  }

  /**
   * Record the latency in live streams.
   *
   * @param {number} seconds
   */
  setLiveLatency(seconds) {
    this.liveLatencySeconds_ = seconds;
  }

  /**
   * Record the presentation's max segment duration.
   *
   * @param {number} seconds
   */
  setMaxSegmentDuration(seconds) {
    this.maxSegmentDurationSeconds_ = seconds;
  }

  /**
   * @param {number} bandwidth
   */
  setCurrentStreamBandwidth(bandwidth) {
    this.currentStreamBandwidth_ = bandwidth;
  }

  /**
   * @param {number} bandwidth
   */
  setBandwidthEstimate(bandwidth) {
    this.bandwidthEstimate_ = bandwidth;
  }

  /**
   * @param {number} size
   */
  setManifestSize(size) {
    this.manifestSizeBytes_ = size;
  }

  /**
   * @param {number} bytesDownloaded
   */
  addBytesDownloaded(bytesDownloaded) {
    if (isNaN(this.bytesDownloaded_)) {
      this.bytesDownloaded_ = bytesDownloaded;
    } else {
      this.bytesDownloaded_ += bytesDownloaded;
    }
  }

  /** */
  addNonFatalError() {
    this.nonFatalErrorCount_++;
  }

  /**
   * @param {number} count
   */
  setManifestPeriodCount(count) {
    this.manifestPeriodCount_ = count;
  }

  /**
   * @param {number} count
   */
  setManifestGapCount(count) {
    this.manifestGapCount_ = count;
  }

  /**
   * @return {!shaka.util.StateHistory}
   */
  getStateHistory() {
    return this.stateHistory_;
  }

  /**
   * @return {!shaka.util.SwitchHistory}
   */
  getSwitchHistory() {
    return this.switchHistory_;
  }

  /**
   * Create a stats blob that we can pass up to the app. This blob will not
   * reference any internal data.
   *
   * @return {shaka.extern.Stats}
   */
  getBlob() {
    return {
      width: this.width_,
      height: this.height_,
      currentCodecs: this.currentCodecs_,
      streamBandwidth: this.currentStreamBandwidth_,
      decodedFrames: this.totalDecodedFrames_,
      droppedFrames: this.totalDroppedFrames_,
      corruptedFrames: this.totalCorruptedFrames_,
      stallsDetected: this.totalStallsDetected_,
      gapsJumped: this.totalGapsJumped_,
      estimatedBandwidth: this.bandwidthEstimate_,
      completionPercent: this.completionPercent_,
      loadLatency: this.loadLatencySeconds_,
      manifestTimeSeconds: this.manifestTimeSeconds_,
      drmTimeSeconds: this.drmTimeSeconds_,
      playTime: this.stateHistory_.getTimeSpentIn('playing'),
      pauseTime: this.stateHistory_.getTimeSpentIn('paused'),
      bufferingTime: this.stateHistory_.getTimeSpentIn('buffering'),
      licenseTime: this.licenseTimeSeconds_,
      liveLatency: this.liveLatencySeconds_,
      maxSegmentDuration: this.maxSegmentDurationSeconds_,
      manifestSizeBytes: this.manifestSizeBytes_,
      bytesDownloaded: this.bytesDownloaded_,
      nonFatalErrorCount: this.nonFatalErrorCount_,
      manifestPeriodCount: this.manifestPeriodCount_,
      manifestGapCount: this.manifestGapCount_,
      stateHistory: this.stateHistory_.getCopy(),
      switchHistory: this.switchHistory_.getCopy(),
    };
  }

  /**
   * Create an empty stats blob. This resembles the stats when we are not
   * playing any content.
   *
   * @return {shaka.extern.Stats}
   */
  static getEmptyBlob() {
    return {
      width: NaN,
      height: NaN,
      currentCodecs: '',
      streamBandwidth: NaN,
      decodedFrames: NaN,
      droppedFrames: NaN,
      corruptedFrames: NaN,
      stallsDetected: NaN,
      gapsJumped: NaN,
      estimatedBandwidth: NaN,
      completionPercent: NaN,
      loadLatency: NaN,
      manifestTimeSeconds: NaN,
      drmTimeSeconds: NaN,
      playTime: NaN,
      pauseTime: NaN,
      bufferingTime: NaN,
      licenseTime: NaN,
      liveLatency: NaN,
      maxSegmentDuration: NaN,
      manifestSizeBytes: NaN,
      bytesDownloaded: NaN,
      nonFatalErrorCount: NaN,
      manifestPeriodCount: NaN,
      manifestGapCount: NaN,
      switchHistory: [],
      stateHistory: [],
    };
  }
};