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.ArrayUtils');
  12. goog.require('shaka.util.FakeEvent');
  13. goog.require('shaka.util.FakeEventTarget');
  14. goog.require('shaka.util.ManifestParserUtils');
  16. /**
  17.  * Monitors the quality of content being appended to the source buffers and
  18.  * fires 'qualitychange' events when the media quality at the playhead changes.
  19.  *
  20.  * @implements {shaka.media.IPlayheadObserver}
  21.  * @final
  22.  */
  23. shaka.media.QualityObserver = class extends shaka.util.FakeEventTarget {
  24.   /**
  25.    * Creates a new QualityObserver.
  26.    *
  27.    * @param {!function():!shaka.extern.BufferedInfo} getBufferedInfo
  28.    *   Buffered info is needed to purge QualityChanges that are no
  29.    *   longer relevant.
  30.    */
  31.   constructor(getBufferedInfo) {
  32.     super();
  34.     /**
  35.      * @private {!Map<string, !shaka.media.QualityObserver.ContentTypeState>}
  36.      */
  37.     this.contentTypeStates_ = new Map();
  39.     /** @private function():!shaka.extern.BufferedInfo */
  40.     this.getBufferedInfo_ = getBufferedInfo;
  41.   }
  43.   /** @override */
  44.   release() {
  45.     this.contentTypeStates_.clear();
  46.     super.release();
  47.   }
  49.   /**
  50.    * Get the ContentTypeState for a contentType, creating a new
  51.    * one if necessary.
  52.    *
  53.    * @param {!string} contentType
  54.    *  The contend type e.g. "video" or "audio".
  55.    * @return {!shaka.media.QualityObserver.ContentTypeState}
  56.    * @private
  57.    */
  58.   getContentTypeState_(contentType) {
  59.     let contentTypeState = this.contentTypeStates_.get(contentType);
  60.     if (!contentTypeState) {
  61.       contentTypeState = {
  62.         qualityChangePositions: [],
  63.         currentQuality: null,
  64.         contentType: contentType,
  65.       };
  66.       this.contentTypeStates_.set(contentType, contentTypeState);
  67.     }
  68.     return contentTypeState;
  69.   }
  71.   /**
  72.    * Adds a QualityChangePosition for the contentType identified by
  73.    * the mediaQuality.contentType.
  74.    *
  75.    * @param {!shaka.extern.MediaQualityInfo} mediaQuality
  76.    * @param {!number} position
  77.    *  Position in seconds of the quality change.
  78.    */
  79.   addMediaQualityChange(mediaQuality, position) {
  80.     const contentTypeState =
  81.       this.getContentTypeState_(mediaQuality.contentType);
  83.     // Remove unneeded QualityChangePosition(s) before adding the new one
  84.     this.purgeQualityChangePositions_(contentTypeState);
  86.     const newChangePosition = {
  87.       mediaQuality: mediaQuality,
  88.       position: position,
  89.     };
  91.     const changePositions = contentTypeState.qualityChangePositions;
  92.     const insertBeforeIndex = changePositions.findIndex(
  93.         (qualityChange) => (qualityChange.position >= position));
  95.     if (insertBeforeIndex >= 0) {
  96.       const duplicatePositions =
  97.         (changePositions[insertBeforeIndex].position == position) ? 1 : 0;
  98.       changePositions.splice(
  99.           insertBeforeIndex, duplicatePositions, newChangePosition);
  100.     } else {
  101.       changePositions.push(newChangePosition);
  102.     }
  103.   }
  105.   /**
  106.    * Determines the media quality at a specific position in the source buffer.
  107.    *
  108.    * @param {!number} position
  109.    *  Position in seconds
  110.    * @param {!shaka.media.QualityObserver.ContentTypeState} contentTypeState
  111.    * @return {?shaka.extern.MediaQualityInfo}
  112.    * @private
  113.    */
  114.   static getMediaQualityAtPosition_(position, contentTypeState) {
  115.     // The qualityChangePositions must be ordered by position ascending
  116.     // Find the last QualityChangePosition prior to the position
  117.     const changePositions = contentTypeState.qualityChangePositions;
  118.     for (let i = changePositions.length - 1; i >= 0; i--) {
  119.       const qualityChange = changePositions[i];
  120.       if (qualityChange.position <= position) {
  121.         return qualityChange.mediaQuality;
  122.       }
  123.     }
  124.     return null;
  125.   }
  127.   /**
  128.    * Determines if two MediaQualityInfo objects are the same or not.
  129.    *
  130.    * @param {?shaka.extern.MediaQualityInfo} mq1
  131.    * @param {?shaka.extern.MediaQualityInfo} mq2
  132.    * @return {boolean}
  133.    * @private
  134.    */
  135.   static mediaQualitiesAreTheSame_(mq1, mq2) {
  136.     if (mq1 === mq2) {
  137.       return true;
  138.     }
  139.     if (!mq1 || !mq2) {
  140.       return false;
  141.     }
  142.     return (mq1.bandwidth == mq2.bandwidth) &&
  143.       (mq1.audioSamplingRate == mq2.audioSamplingRate) &&
  144.       (mq1.codecs == mq2.codecs) &&
  145.       (mq1.contentType == mq2.contentType) &&
  146.       (mq1.frameRate == mq2.frameRate) &&
  147.       (mq1.height == mq2.height) &&
  148.       (mq1.mimeType == mq2.mimeType) &&
  149.       (mq1.channelsCount == mq2.channelsCount) &&
  150.       (mq1.pixelAspectRatio == mq2.pixelAspectRatio) &&
  151.       (mq1.width == mq2.width);
  152.   }
  154.   /** @override */
  155.   poll(positionInSeconds, wasSeeking) {
  156.     for (const contentTypeState of this.contentTypeStates_.values()) {
  157.       const currentQuality = contentTypeState.currentQuality;
  158.       const qualityAtPosition =
  159.         shaka.media.QualityObserver.getMediaQualityAtPosition_(
  160.             positionInSeconds, contentTypeState);
  162.       const differentQualities = qualityAtPosition &&
  163.           !shaka.media.QualityObserver.mediaQualitiesAreTheSame_(
  164.               currentQuality, qualityAtPosition);
  165.       const differentLabel = qualityAtPosition && currentQuality &&
  166.           qualityAtPosition.label && currentQuality.label &&
  167.           currentQuality.label !== qualityAtPosition.label;
  168.       const differentLanguage = qualityAtPosition && currentQuality &&
  169.           qualityAtPosition.language && currentQuality.language &&
  170.           currentQuality.language !== qualityAtPosition.language;
  171.       const differentRoles = qualityAtPosition && currentQuality &&
  172.           qualityAtPosition.roles && currentQuality.roles &&
  173.           !shaka.util.ArrayUtils.equal(currentQuality.roles,
  174.               qualityAtPosition.roles);
  176.       if (differentLabel || differentLanguage || differentRoles) {
  177.         if (this.positionIsBuffered_(
  178.             positionInSeconds, qualityAtPosition.contentType)) {
  179.           contentTypeState.currentQuality = qualityAtPosition;
  181.           const event = new shaka.util.FakeEvent('audiotrackchange', new Map([
  182.             ['quality', qualityAtPosition],
  183.             ['position', positionInSeconds],
  184.           ]));
  185.           this.dispatchEvent(event);
  186.         }
  187.       }
  189.       if (differentQualities) {
  190.         if (this.positionIsBuffered_(
  191.             positionInSeconds, qualityAtPosition.contentType)) {
  192.           contentTypeState.currentQuality = qualityAtPosition;
  194.           shaka.log.debug('Media quality changed at position ' +
  195.             positionInSeconds + ' ' + JSON.stringify(qualityAtPosition));
  197.           const event = new shaka.util.FakeEvent('qualitychange', new Map([
  198.             ['quality', qualityAtPosition],
  199.             ['position', positionInSeconds],
  200.           ]));
  201.           this.dispatchEvent(event);
  202.         }
  203.       }
  204.     }
  205.   }
  207.   /**
  208.    * Determine if a position is buffered for a given content type.
  209.    *
  210.    * @param {!number} position
  211.    * @param {!string} contentType
  212.    * @private
  213.    */
  214.   positionIsBuffered_(position, contentType) {
  215.     const bufferedInfo = this.getBufferedInfo_();
  216.     const bufferedRanges = bufferedInfo[contentType];
  217.     if (bufferedRanges && bufferedRanges.length > 0) {
  218.       const bufferStart = bufferedRanges[0].start;
  219.       const bufferEnd = bufferedRanges[bufferedRanges.length - 1].end;
  220.       if (position >= bufferStart && position < bufferEnd) {
  221.         return true;
  222.       }
  223.     }
  224.     return false;
  225.   }
  227.   /**
  228.    * Removes the QualityChangePosition(s) that are not relevant to the buffered
  229.    * content of the specified contentType. Note that this function is
  230.    * invoked just before adding the quality change info associated with
  231.    * the next media segment to be appended.
  232.    *
  233.    * @param {!shaka.media.QualityObserver.ContentTypeState} contentTypeState
  234.    * @private
  235.    */
  236.   purgeQualityChangePositions_(contentTypeState) {
  237.     const bufferedInfo = this.getBufferedInfo_();
  238.     const bufferedRanges = bufferedInfo[contentTypeState.contentType];
  240.     if (bufferedRanges && bufferedRanges.length > 0) {
  241.       const bufferStart = bufferedRanges[0].start;
  242.       const bufferEnd = bufferedRanges[bufferedRanges.length - 1].end;
  243.       const oldChangePositions = contentTypeState.qualityChangePositions;
  244.       contentTypeState.qualityChangePositions =
  245.         oldChangePositions.filter(
  246.             (qualityChange, index) => {
  247.               // Remove all but last quality change before bufferStart.
  248.               if ((qualityChange.position <= bufferStart) &&
  249.                 (index + 1 < oldChangePositions.length) &&
  250.                 (oldChangePositions[index + 1].position <= bufferStart)) {
  251.                 return false;
  252.               }
  253.               // Remove all quality changes after bufferEnd.
  254.               if (qualityChange.position >= bufferEnd) {
  255.                 return false;
  256.               }
  257.               return true;
  258.             });
  259.     } else {
  260.       // Nothing is buffered; so remove all quality changes.
  261.       contentTypeState.qualityChangePositions = [];
  262.     }
  263.   }
  265.   /**
  266.    * Create a MediaQualityInfo object from a stream object.
  267.    *
  268.    * @param {!shaka.extern.Stream} stream
  269.    * @return {!shaka.extern.MediaQualityInfo}
  270.    */
  271.   static createQualityInfo(stream) {
  272.     const basicQuality = {
  273.       bandwidth: stream.bandwidth || 0,
  274.       audioSamplingRate: null,
  275.       codecs: stream.codecs,
  276.       contentType: stream.type,
  277.       frameRate: null,
  278.       height: null,
  279.       mimeType: stream.mimeType,
  280.       channelsCount: null,
  281.       pixelAspectRatio: null,
  282.       width: null,
  283.       label: null,
  284.       roles: stream.roles,
  285.       language: null,
  286.     };
  287.     if (stream.type == shaka.util.ManifestParserUtils.ContentType.VIDEO) {
  288.       basicQuality.frameRate = stream.frameRate || null;
  289.       basicQuality.height = stream.height || null;
  290.       basicQuality.pixelAspectRatio = stream.pixelAspectRatio || null;
  291.       basicQuality.width = stream.width || null;
  292.     }
  293.     if (stream.type == shaka.util.ManifestParserUtils.ContentType.AUDIO) {
  294.       basicQuality.audioSamplingRate = stream.audioSamplingRate;
  295.       basicQuality.channelsCount = stream.channelsCount;
  296.       basicQuality.label = stream.label || null;
  297.       basicQuality.language = stream.language;
  298.     }
  299.     return basicQuality;
  300.   }
  301. };
  303. /**
  304.  * @typedef {{
  305.  *   mediaQuality: !shaka.extern.MediaQualityInfo,
  306.  *   position: !number
  307.  * }}
  308.  *
  309.  * @description
  310.  * Identifies the position of a media quality change in the
  311.  * source buffer.
  312.  *
  313.  * @property {!shaka.extern.MediaQualityInfo} mediaQuality
  314.  *   The new media quality for content after position in the source buffer.
  315.  * @property {!number} position
  316.  *   A position in seconds in the source buffer
  317.  */
  318. shaka.media.QualityObserver.QualityChangePosition;
  320. /**
  321.  * @typedef {{
  322.  *  qualityChangePositions:
  323.  *   !Array<shaka.media.QualityObserver.QualityChangePosition>,
  324.  *  currentQuality: ?shaka.extern.MediaQualityInfo,
  325.  *  contentType: !string
  326.  * }}
  327.  *
  328.  * @description
  329.  * Contains media quality information for a specific content type
  330.  * e.g. video or audio.
  331.  *
  332.  * @property {!Array<shaka.media.QualityObserver.QualityChangePosition>
  333.  *           } qualityChangePositions
  334.  *   Quality changes ordered by position ascending.
  335.  * @property {?shaka.media.MediaQualityInfo} currentMediaQuality
  336.  *   The media quality at the playhead position.
  337.  * @property {string} contentType
  338.  *   The contentType e.g. 'video' or 'audio'
  339.  */
  340. shaka.media.QualityObserver.ContentTypeState;