Source: lib/media/quality_observer.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.QualityObserver');
  9. goog.require('shaka.media.IPlayheadObserver');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.FakeEvent');
  12. goog.require('shaka.util.FakeEventTarget');
  14. /**
  15.  * Monitors the quality of content being appended to the source buffers and
  16.  * fires 'qualitychange' events when the media quality at the playhead changes.
  17.  *
  18.  * @implements {shaka.media.IPlayheadObserver}
  19.  * @final
  20.  */
  21. shaka.media.QualityObserver = class extends shaka.util.FakeEventTarget {
  22.   /**
  23.    * Creates a new QualityObserver.
  24.    *
  25.    * @param {!function():!shaka.extern.BufferedInfo} getBufferedInfo
  26.    *   Buffered info is needed to purge QualityChanges that are no
  27.    *   longer relevant.
  28.    */
  29.   constructor(getBufferedInfo) {
  30.     super();
  32.     /**
  33.      * @private {!Map.<string,!shaka.media.QualityObserver.ContentTypeState>}
  34.      */
  35.     this.contentTypeStates_ = new Map();
  37.     /** @private function():!shaka.extern.BufferedInfo */
  38.     this.getBufferedInfo_ = getBufferedInfo;
  39.   }
  41.   /** @override */
  42.   release() {
  43.     this.contentTypeStates_.clear();
  44.     super.release();
  45.   }
  47.   /**
  48.    * Get the ContenTypeState for a contentType, creating a new
  49.    * one if necessary.
  50.    *
  51.    * @param {!string} contentType
  52.    *  The contend type e.g. "video" or "audio".
  53.    * @return {!shaka.media.QualityObserver.ContentTypeState}
  54.    * @private
  55.    */
  56.   getContentTypeState_(contentType) {
  57.     let contentTypeState = this.contentTypeStates_.get(contentType);
  58.     if (!contentTypeState) {
  59.       contentTypeState = {
  60.         qualityChangePositions: [],
  61.         currentQuality: null,
  62.         contentType: contentType,
  63.       };
  64.       this.contentTypeStates_.set(contentType, contentTypeState);
  65.     }
  66.     return contentTypeState;
  67.   }
  69.   /**
  70.    * Adds a QualityChangePosition for the contentType identified by
  71.    * the mediaQuality.contentType.
  72.    *
  73.    * @param {!shaka.extern.MediaQualityInfo} mediaQuality
  74.    * @param {!number} position
  75.    *  Position in seconds of the quality change.
  76.    */
  77.   addMediaQualityChange(mediaQuality, position) {
  78.     const contentTypeState =
  79.       this.getContentTypeState_(mediaQuality.contentType);
  81.     // Remove unneeded QualityChangePosition(s) before adding the new one
  82.     this.purgeQualityChangePositions_(contentTypeState);
  84.     const newChangePosition = {
  85.       mediaQuality: mediaQuality,
  86.       position: position,
  87.     };
  89.     const changePositions = contentTypeState.qualityChangePositions;
  90.     const insertBeforeIndex = changePositions.findIndex(
  91.         (qualityChange) => (qualityChange.position >= position));
  93.     if (insertBeforeIndex >= 0) {
  94.       const duplicatePositions =
  95.         (changePositions[insertBeforeIndex].position == position) ? 1 : 0;
  96.       changePositions.splice(
  97.           insertBeforeIndex, duplicatePositions, newChangePosition);
  98.     } else {
  99.       changePositions.push(newChangePosition);
  100.     }
  101.   }
  103.   /**
  104.    * Determines the media quality at a specific position in the source buffer.
  105.    *
  106.    * @param {!number} position
  107.    *  Position in seconds
  108.    * @param {!shaka.media.QualityObserver.ContentTypeState} contentTypeState
  109.    * @return {?shaka.extern.MediaQualityInfo}
  110.    * @private
  111.    */
  112.   static getMediaQualityAtPosition_(position, contentTypeState) {
  113.     // The qualityChangePositions must be ordered by position ascending
  114.     // Find the last QualityChangePosition prior to the position
  115.     const changePositions = contentTypeState.qualityChangePositions;
  116.     for (let i = changePositions.length - 1; i >= 0; i--) {
  117.       const qualityChange = changePositions[i];
  118.       if (qualityChange.position <= position) {
  119.         return qualityChange.mediaQuality;
  120.       }
  121.     }
  122.     return null;
  123.   }
  125.   /**
  126.    * Determines if two MediaQualityInfo objects are the same or not.
  127.    *
  128.    * @param {?shaka.extern.MediaQualityInfo} mq1
  129.    * @param {?shaka.extern.MediaQualityInfo} mq2
  130.    * @return {boolean}
  131.    * @private
  132.    */
  133.   static mediaQualitiesAreTheSame_(mq1, mq2) {
  134.     if (mq1 === mq2) {
  135.       return true;
  136.     }
  137.     if (!mq1 || !mq2) {
  138.       return false;
  139.     }
  140.     return (mq1.bandwidth == mq2.bandwidth) &&
  141.       (mq1.audioSamplingRate == mq2.audioSamplingRate) &&
  142.       (mq1.codecs == mq2.codecs) &&
  143.       (mq1.contentType == mq2.contentType) &&
  144.       (mq1.frameRate == mq2.frameRate) &&
  145.       (mq1.height == mq2.height) &&
  146.       (mq1.mimeType == mq2.mimeType) &&
  147.       (mq1.channelsCount == mq2.channelsCount) &&
  148.       (mq1.pixelAspectRatio == mq2.pixelAspectRatio) &&
  149.       (mq1.width == mq2.width);
  150.   }
  152.   /** @override */
  153.   poll(positionInSeconds, wasSeeking) {
  154.     for (const contentTypeState of this.contentTypeStates_.values()) {
  155.       const qualityAtPosition =
  156.         shaka.media.QualityObserver.getMediaQualityAtPosition_(
  157.             positionInSeconds, contentTypeState);
  158.       if (qualityAtPosition &&
  159.           !shaka.media.QualityObserver.mediaQualitiesAreTheSame_(
  160.               contentTypeState.currentQuality, qualityAtPosition)) {
  161.         if (this.positionIsBuffered_(
  162.             positionInSeconds, qualityAtPosition.contentType)) {
  163.           contentTypeState.currentQuality = qualityAtPosition;
  165.           shaka.log.debug('Media quality changed at position ' +
  166.             positionInSeconds + ' ' + JSON.stringify(qualityAtPosition));
  168.           const event = new shaka.util.FakeEvent('qualitychange', new Map([
  169.             ['quality', qualityAtPosition],
  170.             ['position', positionInSeconds],
  171.           ]));
  172.           this.dispatchEvent(event);
  173.         }
  174.       }
  175.     }
  176.   }
  178.   /**
  179.    * Determine if a position is buffered for a given content type.
  180.    *
  181.    * @param {!number} position
  182.    * @param {!string} contentType
  183.    * @private
  184.    */
  185.   positionIsBuffered_(position, contentType) {
  186.     const bufferedInfo = this.getBufferedInfo_();
  187.     const bufferedRanges = bufferedInfo[contentType];
  188.     if (bufferedRanges && bufferedRanges.length > 0) {
  189.       const bufferStart = bufferedRanges[0].start;
  190.       const bufferEnd = bufferedRanges[bufferedRanges.length - 1].end;
  191.       if (position >= bufferStart && position < bufferEnd) {
  192.         return true;
  193.       }
  194.     }
  195.     return false;
  196.   }
  198.   /**
  199.    * Removes the QualityChangePosition(s) that are not relevant to the buffered
  200.    * content of the specified contentType. Note that this function is
  201.    * invoked just before adding the quality change info associated with
  202.    * the next media segment to be appended.
  203.    *
  204.    * @param {!shaka.media.QualityObserver.ContentTypeState} contentTypeState
  205.    * @private
  206.    */
  207.   purgeQualityChangePositions_(contentTypeState) {
  208.     const bufferedInfo = this.getBufferedInfo_();
  209.     const bufferedRanges = bufferedInfo[contentTypeState.contentType];
  211.     if (bufferedRanges && bufferedRanges.length > 0) {
  212.       const bufferStart = bufferedRanges[0].start;
  213.       const bufferEnd = bufferedRanges[bufferedRanges.length - 1].end;
  214.       const oldChangePositions = contentTypeState.qualityChangePositions;
  215.       contentTypeState.qualityChangePositions =
  216.         oldChangePositions.filter(
  217.             (qualityChange, index) => {
  218.               // Remove all but last quality change before bufferStart.
  219.               if ((qualityChange.position <= bufferStart) &&
  220.                 (index + 1 < oldChangePositions.length) &&
  221.                 (oldChangePositions[index + 1].position <= bufferStart)) {
  222.                 return false;
  223.               }
  224.               // Remove all quality changes after bufferEnd.
  225.               if (qualityChange.position >= bufferEnd) {
  226.                 return false;
  227.               }
  228.               return true;
  229.             });
  230.     } else {
  231.       // Nothing is buffered; so remove all quality changes.
  232.       contentTypeState.qualityChangePositions = [];
  233.     }
  234.   }
  235. };
  237. /**
  238.   * @typedef {{
  239.   *   mediaQuality: !shaka.extern.MediaQualityInfo,
  240.   *   position: !number
  241.   * }}
  242.   *
  243.   * @description
  244.   * Identifies the position of a media quality change in the
  245.   * source buffer.
  246.   *
  247.   * @property {shaka.extern.MediaQualityInfo} !mediaQuality
  248.   *   The new media quality for content after position in the source buffer.
  249.   * @property {number} !position
  250.   *   A position in seconds in the source buffer
  251.   */
  252. shaka.media.QualityObserver.QualityChangePosition;
  254. /**
  255.   * @typedef {{
  256.   *  qualityChangePositions:
  257.   *   !Array.<shaka.media.QualityObserver.QualityChangePosition>,
  258.   *  currentQuality: ?shaka.extern.MediaQualityInfo,
  259.   *  contentType: !string
  260.   * }}
  261.   *
  262.   * @description
  263.   * Contains media quality information for a specific content type
  264.   * e.g. video or audio.
  265.   *
  266.   * @property {!Array.<shaka.media.QualityObserver.QualityChangePosition>}
  267.   * qualityChangePositions
  268.   *   Quality changes ordered by position ascending.
  269.   * @property {?shaka.media.MediaQualityInfo} currentMediaQuality
  270.   *   The media quality at the playhead position.
  271.   * @property {string} contentType
  272.   *   The contentType e.g. 'video' or 'audio'
  273.   */
  274. shaka.media.QualityObserver.ContentTypeState;