shaka-player 3.1.4 → 3.3.0

package/lib/player.js

@@ -22,6 +22,7 @@ goog.require('shaka.media.PlayRateController');
 goog.require('shaka.media.Playhead');
 goog.require('shaka.media.PlayheadObserverManager');
 goog.require('shaka.media.PreferenceBasedCriteria');
+goog.require('shaka.media.QualityObserver');
 goog.require('shaka.media.RegionObserver');
 goog.require('shaka.media.RegionTimeline');
 goog.require('shaka.media.SegmentIndex');
@@ -36,6 +37,7 @@ goog.require('shaka.text.UITextDisplayer');
 goog.require('shaka.text.WebVttGenerator');
 goog.require('shaka.util.AbortableOperation');
 goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.CmcdManager');
 goog.require('shaka.util.ConfigUtils');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
@@ -106,6 +108,32 @@ goog.requireType('shaka.routing.Payload');
  */
 
 
+/**
+ * @event shaka.Player.DownloadFailed
+ * @description Fired when a download has failed, for any reason.
+ *   'downloadfailed'
+ * @property {!shaka.extern.Request} request
+ * @property {?shaka.util.Error} error
+ * @param {number} httpResponseCode
+ * @param {boolean} aborted
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.DownloadHeadersReceived
+ * @description Fired when the networking engine has received the headers for
+ *    a download, but before the body has been downloaded.
+ *    If the HTTP plugin being used does not track this information, this event
+ *    will default to being fired when the body is received, instead.
+ * @property {!Object.<string, string>} headers
+ * @property {!shaka.extern.Request} request
+ * @property {!shaka.net.NetworkingEngine.RequestType} type
+ *   'downloadheadersreceived'
+ * @exportDoc
+ */
+
+
 /**
  * @event shaka.Player.DrmSessionUpdateEvent
  * @description Fired when the CDM has accepted the license response.
@@ -147,6 +175,21 @@ goog.requireType('shaka.routing.Payload');
  * @exportDoc
  */
 
+/**
+ * @event shaka.Player.MediaQualityChangedEvent
+ * @description Fired when the media quality changes at the playhead.
+ * That may be caused by an adaptation change or a DASH period transition.
+ * Separate events are emitted for audio and video contentTypes.
+ * This is supported for only DASH streams at this time.
+ * @property {string} type
+ *   'mediaqualitychanged'
+ * @property {shaka.extern.MediaQualityInfo} mediaQuality
+ *   Information about media quality at the playhead position.
+ * @property {number} position
+ *   The playhead position.
+ * @exportDoc
+ */
+
 
 /**
  * @event shaka.Player.BufferingEvent
@@ -217,6 +260,8 @@ goog.requireType('shaka.routing.Payload');
  *   <code>selectAudioLanguage()</code>, or <code>selectTextLanguage()</code>.
  * @property {string} type
  *   'adaptation'
+ * @property {shaka.extern.Track} oldTrack
+ * @property {shaka.extern.Track} newTrack
  * @exportDoc
  */
 
@@ -439,6 +484,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {shaka.media.RegionTimeline} */
     this.regionTimeline_ = null;
 
+    /** @private {shaka.util.CmcdManager} */
+    this.cmcdManager_ = null;
+
+    /** @private {shaka.media.QualityObserver} */
+    this.qualityObserver_ = null;
+
     /** @private {shaka.media.StreamingEngine} */
     this.streamingEngine_ = null;
 
@@ -505,6 +556,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {!Array.<function():(!Promise|undefined)>} */
     this.cleanupOnUnload_ = [];
 
+    /**
+     * This playback start position will be used when
+     * <code>updateStartTime()</code> has been called to provide an updated
+     * start position during the media loading process.
+     *
+     * @private {?number}
+     */
+    this.updatedStartTime_ = null;
+
     if (dependencyInjector) {
       dependencyInjector(this);
     }
@@ -721,6 +781,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.config_ = null;
     this.stats_ = null;
     this.videoContainer_ = null;
+    this.cmcdManager_ = null;
 
     if (this.networkingEngine_) {
       await this.networkingEngine_.destroy();
@@ -1018,6 +1079,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return this.wrapWalkerListenersWithPromise_(events);
   }
 
+  /**
+   * Provides a way to update the stream start position during the media loading
+   * process. Can for example be called from the <code>manifestparsed</code>
+   * event handler to update the start position based on information in the
+   * manifest.
+   *
+   * @param {number} startTime
+   * @export
+   */
+  updateStartTime(startTime) {
+    this.updatedStartTime_ = startTime;
+  }
+
   /**
    * Tell the player to load the content at <code>assetUri</code> and start
    * playback at <code>startTime</code>. Before calling <code>load</code>,
@@ -1038,6 +1112,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @export
    */
   load(assetUri, startTime, mimeType) {
+    this.updatedStartTime_ = null;
+
     // Do not allow the player to be used after |destroy| is called.
     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
       return Promise.reject(this.createAbortLoadError_());
@@ -1091,6 +1167,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // before we allow calls to |updateStateHistory|.
     this.stats_ = new shaka.util.Stats();
 
+    // Create the CMCD manager so client data can be attached to all requests
+    this.cmcdManager_ = this.createCmcd_();
+
     // Load's request is a little different, so we can't use our normal
     // listeners-to-promise method. It is the only request where we may skip the
     // request, so we need to set the on skip callback to reject with a specific
@@ -1142,25 +1221,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!mimeType) {
       // Try using the uri extension.
       const extension = shaka.media.ManifestParser.getExtension(uri);
-      mimeType = {
-        'mp4': 'video/mp4',
-        'm4v': 'video/mp4',
-        'm4a': 'audio/mp4',
-        'webm': 'video/webm',
-        'weba': 'audio/webm',
-        'mkv': 'video/webm', // Chromium browsers supports it.
-        'ts': 'video/mp2t',
-        'ogv': 'video/ogg',
-        'ogg': 'audio/ogg',
-        'mpg': 'video/mpeg',
-        'mpeg': 'video/mpeg',
-        'm3u8': 'application/x-mpegurl',
-        'mpd': 'application/dash+xml',
-        'mp3': 'audio/mpeg',
-        'aac': 'audio/aac',
-        'flac': 'audio/flac',
-        'wav': 'audio/wav',
-      }[extension];
+      mimeType = shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_[extension];
     }
 
     // TODO: The load graph system has a design limitation that requires routing
@@ -1610,6 +1671,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     goog.asserts.assert(
         this.networkingEngine_,
         'Need networking engine to parse manifest.');
+    goog.asserts.assert(
+        this.cmcdManager_,
+        'Need CMCD manager to populate manifest request data.');
     goog.asserts.assert(
         this.config_,
         'Need player config to parse manifest.');
@@ -1633,12 +1697,24 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.adManager_.onDashTimedMetadata(region);
       }
     });
+    this.qualityObserver_ = null;
+    if (this.config_.streaming.observeQualityChanges) {
+      this.qualityObserver_ = new shaka.media.QualityObserver(
+          () => this.getBufferedInfo());
+      this.qualityObserver_.setListeners((mediaQualityInfo, position) => {
+        this.onMediaQualityChange_(mediaQualityInfo, position);
+      });
+    }
 
-    // TODO (#1391): Once filterManifest_ is async, remove this eslint disable.
-    /* eslint-disable require-await */
     const playerInterface = {
       networkingEngine: networkingEngine,
-      filter: async (manifest) => this.filterManifest_(manifest),
+      modifyManifestRequest: (request, manifestInfo) => {
+        this.cmcdManager_.applyManifestData(request, manifestInfo);
+      },
+      modifySegmentRequest: (request, segmentInfo) => {
+        this.cmcdManager_.applySegmentData(request, segmentInfo);
+      },
+      filter: (manifest) => this.filterManifest_(manifest),
       makeTextStreamsForClosedCaptions: (manifest) => {
         return this.makeTextStreamsForClosedCaptions_(manifest);
       },
@@ -1656,7 +1732,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.configure('streaming.lowLatencyMode', true);
       },
     };
-    /* eslint-enable require-await */
 
     const startTime = Date.now() / 1000;
 
@@ -1748,17 +1823,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       },
     });
 
-    // TODO: remove once MediaCap implementation is complete.
-    if (!this.config_.useMediaCapabilities) {
-      shaka.util.StreamUtils.filterManifestByMediaSource(this.manifest_);
-    }
-
     this.drmEngine_.configure(this.config_.drm);
 
     await this.drmEngine_.initForPlayback(
         this.manifest_.variants,
-        this.manifest_.offlineSessionIds,
-        this.config_.useMediaCapabilities);
+        this.manifest_.offlineSessionIds);
 
     await this.drmEngine_.attach(has.mediaElement);
 
@@ -1805,6 +1874,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // something we are now depending on.
     has.startTime = wants.startTime;
 
+    // If updateStartTime() has been called since load() was invoked use the
+    // requested startTime
+    if (this.updatedStartTime_ != null) {
+      has.startTime = this.updatedStartTime_;
+      this.updatedStartTime_ = null;
+    }
+
     // Store a reference to values in |has| after asserting so that closure will
     // know that they will still be non-null between calls to await.
     const mediaElement = has.mediaElement;
@@ -1873,7 +1949,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // If the content is multi-codec and the browser can play more than one of
     // them, choose codecs now before we initialize streaming.
     shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
-        this.manifest_, this.config_.preferredAudioChannelCount);
+        this.manifest_,
+        this.config_.preferredVideoCodecs,
+        this.config_.preferredAudioCodecs,
+        this.config_.preferredAudioChannelCount,
+        this.config_.preferredDecodingAttributes);
 
     this.streamingEngine_ = this.createStreamingEngine();
     this.streamingEngine_.configure(this.config_.streaming);
@@ -1912,7 +1992,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
 
       // Since the first streams just became active, send an adaptation event.
-      this.onAdaptation_();
+      this.onAdaptation_(null,
+          shaka.util.StreamUtils.variantToTrack(initialVariant));
     }
 
     // Decide if text should be shown automatically.
@@ -2025,6 +2106,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     this.drmEngine_.configure(this.config_.drm);
 
+    const uri = wants.uri || '';
+    const extension = shaka.media.ManifestParser.getExtension(uri);
+    let mimeType = shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_[extension];
+    if (mimeType == 'application/x-mpegurl' && shaka.util.Platform.isApple()) {
+      mimeType = 'application/vnd.apple.mpegurl';
+    }
+    if (!mimeType) {
+      mimeType = 'video/mp4';
+    }
+
     // TODO: Instead of feeding DrmEngine with Variants, we should refactor
     // DrmEngine so that it takes a minimal config derived from Variants.  In
     // cases like this one or in removal of stored content, the details are
@@ -2045,7 +2136,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         createSegmentIndex: () => Promise.resolve(),
         segmentIndex: null,
         mimeType: wants.mimeType ?
-            shaka.util.MimeUtils.getBasicType(wants.mimeType) : 'video/mp4',
+            shaka.util.MimeUtils.getBasicType(wants.mimeType) : mimeType,
         codecs: wants.mimeType ?
             shaka.util.MimeUtils.getCodecs(wants.mimeType) : '',
         encrypted: true,
@@ -2164,8 +2255,22 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
     if (this.video_.textTracks) {
       this.eventManager_.listen(this.video_.textTracks, 'addtrack', (e) => {
-        this.onTracksChanged_();
-        this.processTimedMetadataSrcEqls_(/** @type {!TrackEvent} */(e));
+        const trackEvent = /** @type {!TrackEvent} */(e);
+        if (trackEvent.track) {
+          const track = trackEvent.track;
+          goog.asserts.assert(track instanceof TextTrack, 'Wrong track type!');
+          switch (track.kind) {
+            case 'metadata':
+              this.processTimedMetadataSrcEqls_(track);
+              break;
+            case 'chapters':
+              this.processChaptersTrack_(track);
+              break;
+            default:
+              this.onTracksChanged_();
+              break;
+          }
+        }
       });
       this.eventManager_.listen(
           this.video_.textTracks, 'removetrack', () => this.onTracksChanged_());
@@ -2173,9 +2278,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           this.video_.textTracks, 'change', () => this.onTracksChanged_());
     }
 
+    const extension = shaka.media.ManifestParser.getExtension(has.uri);
+    const mimeType =
+      shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_[extension];
+
     // By setting |src| we are done "loading" with src=. We don't need to set
     // the current time because |playhead| will do that for us.
-    has.mediaElement.src = has.uri;
+    has.mediaElement.src = this.cmcdManager_.appendSrcData(has.uri, mimeType);
 
     // Tizen 3 / WebOS won't load anything unless you call load() explicitly,
     // no matter the value of the preload attribute.  This is harmful on some
@@ -2338,13 +2447,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * We're looking for metadata tracks to process id3 tags. One of the uses is
    * for ad info on LIVE streams
    *
-   * @param {!TrackEvent} event
+   * @param {!TextTrack} track
    * @private
    */
-  processTimedMetadataSrcEqls_(event) {
-    const track = event.track;
-    goog.asserts.assert(track instanceof TextTrack, 'Wrong track type!');
-
+  processTimedMetadataSrcEqls_(track) {
     if (track.kind != 'metadata') {
       return;
     }
@@ -2424,6 +2530,32 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
+  /**
+   * We're looking for chapters tracks to process the chapters.
+   *
+   * @param {?TextTrack} track
+   * @private
+   */
+  processChaptersTrack_(track) {
+    if (!track || track.kind != 'chapters') {
+      return;
+    }
+
+    // Hidden mode is required for the cuechange event to launch correctly and
+    // get the cues and the activeCues
+    track.mode = 'hidden';
+
+    // In Safari the initial assignment does not always work, so we schedule
+    // this process to be repeated several times to ensure that it has been put
+    // in the correct mode.
+    new shaka.util.Timer(() => {
+      const chaptersTracks = this.getChaptersTracks_();
+      for (const chaptersTrack of chaptersTracks) {
+        chaptersTrack.mode = 'hidden';
+      }
+    }).tickNow().tickAfter(/* seconds= */ 0.5);
+  }
+
   /**
    * Take a series of variants and ensure that they only contain one type of
    * variant. The different options are:
@@ -2482,7 +2614,30 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.abrManager_.segmentDownloaded(deltaTimeMs, bytesDownloaded);
       }
     };
-    return new shaka.net.NetworkingEngine(onProgressUpdated_);
+    /** @type {shaka.net.NetworkingEngine.OnHeadersReceived} */
+    const onHeadersReceived_ = (headers, request, requestType) => {
+      // Release a 'downloadheadersreceived' event.
+      const name = shaka.Player.EventName.DownloadHeadersReceived;
+      const data = new Map()
+          .set('headers', headers)
+          .set('request', request)
+          .set('requestType', requestType);
+      this.dispatchEvent(this.makeEvent_(name, data));
+    };
+    /** @type {shaka.net.NetworkingEngine.OnDownloadFailed} */
+    const onDownloadFailed_ = (request, error, httpResponseCode, aborted) => {
+      // Release a 'downloadfailed' event.
+      const name = shaka.Player.EventName.DownloadFailed;
+      const data = new Map()
+          .set('request', request)
+          .set('error', error)
+          .set('httpResponseCode', httpResponseCode)
+          .set('aborted', aborted);
+      this.dispatchEvent(this.makeEvent_(name, data));
+    };
+
+    return new shaka.net.NetworkingEngine(
+        onProgressUpdated_, onHeadersReceived_, onDownloadFailed_);
   }
 
   /**
@@ -2538,7 +2693,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Now that we have all our observers, create a manager for them.
     const manager = new shaka.media.PlayheadObserverManager(this.video_);
     manager.manage(regionObserver);
-
+    if (this.qualityObserver_) {
+      manager.manage(this.qualityObserver_);
+    }
     return manager;
   }
 
@@ -2654,6 +2811,27 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         mediaElement, closedCaptionsParser, textDisplayer, onMetadata);
   }
 
+  /**
+   * Create a new CMCD manager.
+   *
+   * @private
+   */
+  createCmcd_() {
+    const abr = this.abrManager_;
+
+    /** @type {shaka.util.CmcdManager.PlayerInterface} */
+    const playerInterface = {
+      getBandwidthEstimate: () => abr ? abr.getBandwidthEstimate() : NaN,
+      getBufferedInfo: () => this.getBufferedInfo(),
+      getCurrentTime: () => this.video_ ? this.video_.currentTime : 0,
+      getManifest: () => this.manifest_,
+      getPlaybackRate: () => this.getPlaybackRate(),
+      isLive: () => this.isLive(),
+    };
+
+    return new shaka.util.CmcdManager(playerInterface, this.config_.cmcd);
+  }
+
   /**
    * Creates a new instance of StreamingEngine.  This can be replaced by tests
    * to create fake instances instead.
@@ -2663,19 +2841,28 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   createStreamingEngine() {
     goog.asserts.assert(
         this.playhead_ && this.abrManager_ && this.mediaSourceEngine_ &&
-        this.manifest_,
+        this.cmcdManager_ && this.manifest_,
         'Must not be destroyed');
 
     /** @type {shaka.media.StreamingEngine.PlayerInterface} */
     const playerInterface = {
       getPresentationTime: () => this.playhead_.getTime(),
       getBandwidthEstimate: () => this.abrManager_.getBandwidthEstimate(),
+      modifySegmentRequest: (request, segmentInfo) => {
+        this.cmcdManager_.applySegmentData(request, segmentInfo);
+      },
       mediaSourceEngine: this.mediaSourceEngine_,
       netEngine: this.networkingEngine_,
       onError: (error) => this.onError_(error),
       onEvent: (event) => this.dispatchEvent(event),
       onManifestUpdate: () => this.onManifestUpdate_(),
       onSegmentAppended: () => this.onSegmentAppended_(),
+      onInitSegmentAppended: (position, initSegment) => {
+        const mediaQuality = initSegment.getMediaQuality();
+        if (mediaQuality && this.qualityObserver_) {
+          this.qualityObserver_.addMediaQualityChange(mediaQuality, position);
+        }
+      },
     };
 
     return new shaka.media.StreamingEngine(this.manifest_, playerInterface);
@@ -2868,6 +3055,32 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return this.config_;
   }
 
+  /**
+   * Returns the ratio of video length buffered compared to buffering Goal
+   * @return {number}
+   * @export
+   */
+  getBufferFullness() {
+    if (this.video_) {
+      const bufferedLength = this.video_.buffered.length;
+      const bufferedEnd =
+          bufferedLength ? this.video_.buffered.end(bufferedLength - 1) : 0;
+      const bufferingGoal = this.getConfiguration().streaming.bufferingGoal;
+      const lengthToBeBuffered = Math.min(this.video_.currentTime +
+          bufferingGoal, this.seekRange().end);
+
+      if (bufferedEnd >= lengthToBeBuffered) {
+        return 1;
+      } else if (bufferedEnd <= this.video_.currentTime) {
+        return 0;
+      } else if (bufferedEnd < lengthToBeBuffered) {
+        return ((bufferedEnd - this.video_.currentTime) /
+            (lengthToBeBuffered - this.video_.currentTime));
+      }
+    }
+    return 0;
+  }
+
   /**
    * Reset configuration to default.
    * @export
@@ -3078,6 +3291,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return {'start': 0, 'end': 0};
   }
 
+  /**
+   * Go to live in a live stream.
+   *
+   * @export
+   */
+  goToLive() {
+    if (this.isLive()) {
+      this.video_.currentTime = this.seekRange().end;
+    } else {
+      shaka.log.warning('goToLive is for live streams!');
+    }
+  }
+
   /**
    * Get the key system currently used by EME. If EME is not being used, this
    * will return an empty string. If the player has not loaded content, this
@@ -3102,6 +3328,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return this.drmEngine_ ? this.drmEngine_.getDrmInfo() : null;
   }
 
+
+  /**
+   * Get the drm engine.
+   * This method should only be used for testing. Applications SHOULD NOT
+   * use this in production.
+   *
+   * @return {?shaka.media.DrmEngine}
+   */
+  getDrmEngine() {
+    return this.drmEngine_;
+  }
+
+
   /**
    * Get the next known expiration time for any EME session. If the session
    * never expires, this will return <code>Infinity</code>. If there are no EME
@@ -3356,9 +3595,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         return null;
       }
       const reference = imageStream.segmentIndex.get(referencePosition);
+      const tilesLayout =
+          reference.getTilesLayout() || imageStream.tilesLayout;
       // This expression is used to detect one or more numbers (0-9) followed
       // by an x and after one or more numbers (0-9)
-      const match = /(\d+)x(\d+)/.exec(imageStream.tilesLayout);
+      const match = /(\d+)x(\d+)/.exec(tilesLayout);
       if (!match) {
         shaka.log.warning('Tiles layout does not contain a valid format ' +
             ' (columns x rows)');
@@ -3598,36 +3839,34 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           new shaka.media.PreferenceBasedCriteria(language, role || '',
           /* channelCount= */ 0, /* label= */ '');
 
-      if (!this.config_.abr.enabled) {
-        const diff = (a, b) => {
-          if (!a.video && !b.video) {
-            return 0;
-          } else if (!a.video || !b.video) {
-            return Infinity;
-          } else {
-            return Math.abs((a.video.height || 0) - (b.video.height || 0)) +
+      const diff = (a, b) => {
+        if (!a.video && !b.video) {
+          return 0;
+        } else if (!a.video || !b.video) {
+          return Infinity;
+        } else {
+          return Math.abs((a.video.height || 0) - (b.video.height || 0)) +
                 Math.abs((a.video.width || 0) - (b.video.width || 0));
-          }
-        };
+        }
+      };
         // Find the variant whose size is closest to the active variant.  This
         // ensures we stay at about the same resolution when just changing the
         // language/role.
-        const active = this.streamingEngine_.getCurrentVariant();
-        const set =
+      const active = this.streamingEngine_.getCurrentVariant();
+      const set =
             this.currentAdaptationSetCriteria_.create(this.manifest_.variants);
-        let bestVariant = null;
-        for (const curVariant of set.values()) {
-          if (!bestVariant ||
+      let bestVariant = null;
+      for (const curVariant of set.values()) {
+        if (!bestVariant ||
               diff(bestVariant, active) > diff(curVariant, active)) {
-            bestVariant = curVariant;
-          }
-        }
-        if (bestVariant) {
-          const track = shaka.util.StreamUtils.variantToTrack(bestVariant);
-          this.selectVariantTrack(track, /* clearBuffer= */ true);
-          return;
+          bestVariant = curVariant;
         }
       }
+      if (bestVariant) {
+        const track = shaka.util.StreamUtils.variantToTrack(bestVariant);
+        this.selectVariantTrack(track, /* clearBuffer= */ true);
+        return;
+      }
 
       // If we haven't switched yet, just use ABR to find a new track.
       this.chooseVariantAndSwitch_();
@@ -3771,6 +4010,51 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return expected;
   }
 
+  /**
+   * Return a list of chapters tracks.
+   *
+   * @return {!Array.<shaka.extern.Track>}
+   * @export
+   */
+  getChaptersTracks() {
+    if (this.video_ && this.video_.src && this.video_.textTracks) {
+      const textTracks = this.getChaptersTracks_();
+      const StreamUtils = shaka.util.StreamUtils;
+      return textTracks.map((text) => StreamUtils.html5TextTrackToTrack(text));
+    } else {
+      return [];
+    }
+  }
+
+  /**
+   * This returns the list of chapters.
+   *
+   * @param {string} language
+   * @return {!Array.<shaka.extern.Chapter>}
+   * @export
+   */
+  getChapters(language) {
+    const LanguageUtils = shaka.util.LanguageUtils;
+    const inputlanguage = LanguageUtils.normalize(language);
+    const chaptersTracks = this.getChaptersTracks_();
+    const chaptersTrack = chaptersTracks
+        .find((t) => LanguageUtils.normalize(t.language) == inputlanguage);
+    if (!chaptersTrack || !chaptersTrack.cues) {
+      return [];
+    }
+    const chapters = [];
+    for (const cue of chaptersTrack.cues) {
+      /** @type {shaka.extern.Chapter} */
+      const chapter = {
+        title: cue.text,
+        startTime: cue.startTime,
+        endTime: cue.endTime,
+      };
+      chapters.push(chapter);
+    }
+    return chapters;
+  }
+
   /**
    * Ignore the TextTracks with the 'metadata' or 'chapters' kind, or the one
    * generated by the SimpleTextDisplayer.
@@ -3799,6 +4083,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         .filter((t) => t.kind == 'metadata');
   }
 
+  /**
+   * Get the TextTracks with the 'chapters' kind.
+   *
+   * @return {!Array.<TextTrack>}
+   * @private
+   */
+  getChaptersTracks_() {
+    goog.asserts.assert(this.video_.textTracks,
+        'TextTracks should be valid.');
+    return Array.from(this.video_.textTracks)
+        .filter((t) => t.kind == 'chapters');
+  }
+
   /**
    * Enable or disable the text displayer.  If the player is in an unloaded
    * state, the request will be applied next time content is loaded.
@@ -4100,16 +4397,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!mimeType) {
       // Try using the uri extension.
       const extension = shaka.media.ManifestParser.getExtension(uri);
-      mimeType = {
-        'sbv': 'text/x-subviewer',
-        'srt': 'text/srt',
-        'vtt': 'text/vtt',
-        'webvtt': 'text/vtt',
-        'ttml': 'application/ttml+xml',
-        'lrc': 'application/x-subtitle-lrc',
-        'ssa': 'text/x-ssa',
-        'ass': 'text/x-ssa',
-      }[extension];
+      mimeType = shaka.Player.TEXT_EXTENSIONS_TO_MIME_TYPES_[extension];
 
       if (!mimeType) {
         shaka.log.error(
@@ -4138,7 +4426,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
       const trackElement =
         /** @type {!HTMLTrackElement} */(document.createElement('track'));
-      trackElement.src = uri;
+      trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
       trackElement.label = label || '';
       trackElement.kind = kind;
       trackElement.srclang = language;
@@ -4257,74 +4545,23 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     if (!mimeType) {
-      // Try using the uri extension.
-      const extension = shaka.media.ManifestParser.getExtension(uri);
-      mimeType = {
-        'sbv': 'text/x-subviewer',
-        'srt': 'text/srt',
-        'vtt': 'text/vtt',
-        'webvtt': 'text/vtt',
-        'ttml': 'application/ttml+xml',
-        'lrc': 'application/x-subtitle-lrc',
-        'ssa': 'text/x-ssa',
-        'ass': 'text/x-ssa',
-      }[extension];
-
-      if (!mimeType) {
-        try {
-          goog.asserts.assert(
-              this.networkingEngine_, 'Need networking engine.');
-          // eslint-disable-next-line require-atomic-updates
-          mimeType = await shaka.media.ManifestParser.getMimeType(uri,
-              this.networkingEngine_,
-              this.config_.streaming.retryParameters);
-        } catch (error) {}
-      }
+      mimeType = await this.getTextMimetype_(uri);
+    }
 
-      if (!mimeType) {
-        shaka.log.error(
-            'The mimeType has not been provided and it could not be deduced ' +
-            'from its extension.');
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.RECOVERABLE,
-            shaka.util.Error.Category.TEXT,
-            shaka.util.Error.Code.TEXT_COULD_NOT_GUESS_MIME_TYPE,
-            extension);
-      }
+    let adCuePoints = [];
+    if (this.adManager_) {
+      try {
+        adCuePoints = this.adManager_.getServerSideCuePoints();
+      } catch (error) {}
     }
 
     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
-      if (mimeType != 'text/vtt') {
-        goog.asserts.assert(
-            this.networkingEngine_, 'Need networking engine.');
-        const data = await this.getTextData_(uri,
-            this.networkingEngine_,
-            this.config_.streaming.retryParameters);
-        const vvtText = this.convertToWebVTT_(data, mimeType);
-        const blob = new Blob([vvtText], {type: 'text/vtt'});
-        uri = shaka.media.MediaSourceEngine.createObjectURL(blob);
-        mimeType = 'text/vtt';
-      }
       if (forced) {
         // See: https://github.com/whatwg/html/issues/4472
         kind = 'forced';
       }
-      const trackElement =
-        /** @type {!HTMLTrackElement} */(document.createElement('track'));
-      trackElement.src = uri;
-      trackElement.label = label || '';
-      trackElement.kind = kind;
-      trackElement.srclang = language;
-      // Because we're pulling in the text track file via Javascript, the
-      // same-origin policy applies. If you'd like to have a player served
-      // from one domain, but the text track served from another, you'll
-      // need to enable CORS in order to do so. In addition to enabling CORS
-      // on the server serving the text tracks, you will need to add the
-      // crossorigin attribute to the video element itself.
-      if (!this.video_.getAttribute('crossorigin')) {
-        this.video_.setAttribute('crossorigin', 'anonymous');
-      }
-      this.video_.appendChild(trackElement);
+      await this.addSrcTrackElement_(uri, language, kind, mimeType, label || '',
+          adCuePoints);
       const textTracks = this.getTextTracks();
       const srcTrack = textTracks.find((t) => {
         return t.language == language &&
@@ -4354,6 +4591,18 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           shaka.util.Error.Code.CANNOT_ADD_EXTERNAL_TEXT_TO_LIVE_STREAM);
     }
 
+    if (adCuePoints.length) {
+      goog.asserts.assert(
+          this.networkingEngine_, 'Need networking engine.');
+      const data = await this.getTextData_(uri,
+          this.networkingEngine_,
+          this.config_.streaming.retryParameters);
+      const vvtText = this.convertToWebVTT_(data, mimeType, adCuePoints);
+      const blob = new Blob([vvtText], {type: 'text/vtt'});
+      uri = shaka.media.MediaSourceEngine.createObjectURL(blob);
+      mimeType = 'text/vtt';
+    }
+
     /** @type {shaka.extern.Stream} */
     const stream = {
       id: this.nextExternalStreamId_++,
@@ -4399,6 +4648,138 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return shaka.util.StreamUtils.textStreamToTrack(stream);
   }
 
+  /**
+   * Adds the given chapters track to the loaded manifest.  <code>load()</code>
+   * must resolve before calling.  The presentation must have a duration.
+   *
+   * This returns the created track.
+   *
+   * @param {string} uri
+   * @param {string} language
+   * @param {string=} mimeType
+   * @return {!Promise.<shaka.extern.Track>}
+   * @export
+   */
+  async addChaptersTrack(uri, language, mimeType) {
+    if (this.loadMode_ != shaka.Player.LoadMode.MEDIA_SOURCE &&
+        this.loadMode_ != shaka.Player.LoadMode.SRC_EQUALS) {
+      shaka.log.error(
+          'Must call load() and wait for it to resolve before adding ' +
+          'chapters tracks.');
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.RECOVERABLE,
+          shaka.util.Error.Category.PLAYER,
+          shaka.util.Error.Code.CONTENT_NOT_LOADED);
+    }
+
+    if (!mimeType) {
+      mimeType = await this.getTextMimetype_(uri);
+    }
+    let adCuePoints = [];
+    if (this.adManager_) {
+      try {
+        adCuePoints = this.adManager_.getServerSideCuePoints();
+      } catch (error) {}
+    }
+    await this.addSrcTrackElement_(uri, language, /* kind= */ 'chapters',
+        mimeType, /* label= */ '', adCuePoints);
+    const chaptersTracks = this.getChaptersTracks();
+    const chaptersTrack = chaptersTracks.find((t) => {
+      return t.language == language;
+    });
+    if (chaptersTrack) {
+      const html5ChaptersTracks = this.getChaptersTracks_();
+      for (const html5ChaptersTrack of html5ChaptersTracks) {
+        this.processChaptersTrack_(html5ChaptersTrack);
+      }
+      return chaptersTrack;
+    }
+    // This should not happen, but there are browser implementations that may
+    // not support the Track element.
+    shaka.log.error('Cannot add this text when loaded with src=');
+    throw new shaka.util.Error(
+        shaka.util.Error.Severity.RECOVERABLE,
+        shaka.util.Error.Category.TEXT,
+        shaka.util.Error.Code.CANNOT_ADD_EXTERNAL_TEXT_TO_SRC_EQUALS);
+  }
+
+  /**
+   * @param {string} uri
+   * @return {!Promise.<string>}
+   * @private
+   */
+  async getTextMimetype_(uri) {
+    // Try using the uri extension.
+    const extension = shaka.media.ManifestParser.getExtension(uri);
+    let mimeType = shaka.Player.TEXT_EXTENSIONS_TO_MIME_TYPES_[extension];
+
+    if (mimeType) {
+      return mimeType;
+    }
+
+    try {
+      goog.asserts.assert(
+          this.networkingEngine_, 'Need networking engine.');
+      // eslint-disable-next-line require-atomic-updates
+      mimeType = await shaka.media.ManifestParser.getMimeType(uri,
+          this.networkingEngine_,
+          this.config_.streaming.retryParameters);
+    } catch (error) {}
+
+    if (mimeType) {
+      return mimeType;
+    }
+
+    shaka.log.error(
+        'The mimeType has not been provided and it could not be deduced ' +
+        'from its extension.');
+    throw new shaka.util.Error(
+        shaka.util.Error.Severity.RECOVERABLE,
+        shaka.util.Error.Category.TEXT,
+        shaka.util.Error.Code.TEXT_COULD_NOT_GUESS_MIME_TYPE,
+        extension);
+  }
+
+  /**
+   * @param {string} uri
+   * @param {string} language
+   * @param {string} kind
+   * @param {string} mimeType
+   * @param {string} label
+   * @param {!Array.<!shaka.extern.AdCuePoint>} adCuePoints
+   * @private
+   */
+  async addSrcTrackElement_(uri, language, kind, mimeType, label,
+      adCuePoints) {
+    if (mimeType != 'text/vtt' || adCuePoints.length) {
+      goog.asserts.assert(
+          this.networkingEngine_, 'Need networking engine.');
+      const data = await this.getTextData_(uri,
+          this.networkingEngine_,
+          this.config_.streaming.retryParameters);
+      const vvtText = this.convertToWebVTT_(data, mimeType, adCuePoints);
+      const blob = new Blob([vvtText], {type: 'text/vtt'});
+      uri = shaka.media.MediaSourceEngine.createObjectURL(blob);
+      mimeType = 'text/vtt';
+    }
+    const trackElement =
+      /** @type {!HTMLTrackElement} */(document.createElement('track'));
+    trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
+    trackElement.label = label;
+    trackElement.kind = kind;
+    trackElement.srclang = language;
+    // Because we're pulling in the text track file via Javascript, the
+    // same-origin policy applies. If you'd like to have a player served
+    // from one domain, but the text track served from another, you'll
+    // need to enable CORS in order to do so. In addition to enabling CORS
+    // on the server serving the text tracks, you will need to add the
+    // crossorigin attribute to the video element itself.
+    if (!this.video_.getAttribute('crossorigin')) {
+      this.video_.setAttribute('crossorigin', 'anonymous');
+    }
+    this.video_.appendChild(trackElement);
+  }
+
   /**
    * @param {string} uri
    * @param {!shaka.net.NetworkingEngine} netEngine
@@ -4412,6 +4793,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
     request.method = 'GET';
 
+    this.cmcdManager_.applyTextData(request);
+
     const response = await netEngine.request(type, request).promise;
 
     return response.data;
@@ -4423,10 +4806,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    *
    * @param {BufferSource} buffer
    * @param {string} mimeType
+   * @param {!Array.<!shaka.extern.AdCuePoint>} adCuePoints
    * @return {string}
    * @private
    */
-  convertToWebVTT_(buffer, mimeType) {
+  convertToWebVTT_(buffer, mimeType, adCuePoints) {
     const factory = shaka.text.TextEngine.findParser(mimeType);
     if (factory) {
       const obj = factory();
@@ -4437,7 +4821,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       };
       const data = shaka.util.BufferUtils.toUint8(buffer);
       const cues = obj.parseMedia(data, time);
-      return shaka.text.WebVttGenerator.convert(cues);
+      return shaka.text.WebVttGenerator.convert(cues, adCuePoints);
     }
     throw new shaka.util.Error(
         shaka.util.Error.Severity.CRITICAL,
@@ -4679,8 +5063,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.streamingEngine_.getCurrentVariant() : null;
 
     await shaka.util.StreamUtils.filterManifest(
-        this.drmEngine_, currentVariant, manifest,
-        this.config_.useMediaCapabilities);
+        this.drmEngine_, currentVariant, manifest);
     this.checkPlayableVariants_(manifest);
   }
 
@@ -4809,6 +5192,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     if (loaded) {
       this.playRateController_.setBuffering(isBuffering);
+      if (this.cmcdManager_) {
+        this.cmcdManager_.setBuffering(isBuffering);
+      }
       this.updateStateHistory_();
     }
 
@@ -4984,9 +5370,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (chosenVariant) {
       this.switchVariant_(chosenVariant, /* fromAdaptation= */ true,
           /* clearBuffers= */ true, /* safeMargin= */ 0);
-      // Send an adaptation event so that the UI can show the new
-      // language/tracks.
-      this.onAdaptation_();
     }
   }
 
@@ -5017,8 +5400,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       oldTrack = shaka.util.StreamUtils.variantToTrack(currentVariant);
     }
     const newTrack = shaka.util.StreamUtils.variantToTrack(variant);
-    // Dispatch a 'variantchanged' event
-    this.onVariantChanged_(oldTrack, newTrack);
+
+    if (fromAdaptation) {
+      // Dispatch an 'adaptation' event
+      this.onAdaptation_(oldTrack, newTrack);
+    } else {
+      // Dispatch a 'variantchanged' event
+      this.onVariantChanged_(oldTrack, newTrack);
+    }
   }
 
   /**
@@ -5162,19 +5551,23 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return;
     }
 
-    this.addVariantToSwitchHistory_(variant, /* fromAdaptation= */ true);
-    this.streamingEngine_.switchVariant(variant, clearBuffer, safeMargin);
-    this.onAdaptation_();
+    this.switchVariant_(variant, /* fromAdaptation= */ true,
+        clearBuffer, safeMargin);
   }
 
   /**
    * Dispatches an 'adaptation' event.
+   * @param {?shaka.extern.Track} from
+   * @param {shaka.extern.Track} to
    * @private
    */
-  onAdaptation_() {
+  onAdaptation_(from, to) {
     // Delay the 'adaptation' event so that StreamingEngine has time to absorb
     // the changes before the user tries to query it.
-    const event = this.makeEvent_(shaka.Player.EventName.Adaptation);
+    const data = new Map()
+        .set('oldTrack', from)
+        .set('newTrack', to);
+    const event = this.makeEvent_(shaka.Player.EventName.Adaptation, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -5276,6 +5669,38 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
+  /**
+   * When notified of a media quality change we need to emit a
+   * MediaQualityChange event to the app.
+   *
+   * @param {shaka.extern.MediaQualityInfo} mediaQuality
+   * @param {number} position
+   *
+   * @private
+   */
+  onMediaQualityChange_(mediaQuality, position) {
+    // Always make a copy to avoid exposing our internal data to the app.
+    const clone = {
+      bandwidth: mediaQuality.bandwidth,
+      audioSamplingRate: mediaQuality.audioSamplingRate,
+      codecs: mediaQuality.codecs,
+      contentType: mediaQuality.contentType,
+      frameRate: mediaQuality.frameRate,
+      height: mediaQuality.height,
+      mimeType: mediaQuality.mimeType,
+      channelsCount: mediaQuality.channelsCount,
+      pixelAspectRatio: mediaQuality.pixelAspectRatio,
+      width: mediaQuality.width,
+    };
+
+    const data = new Map()
+        .set('mediaQuality', clone)
+        .set('position', position);
+
+    this.dispatchEvent(this.makeEvent_(
+        shaka.Player.EventName.MediaQualityChanged, data));
+  }
+
   /**
    * Turn the media element's error object into a Shaka Player error object.
    *
@@ -6039,6 +6464,8 @@ shaka.Player.EventName = {
   AbrStatusChanged: 'abrstatuschanged',
   Adaptation: 'adaptation',
   Buffering: 'buffering',
+  DownloadFailed: 'downloadfailed',
+  DownloadHeadersReceived: 'downloadheadersreceived',
   DrmSessionUpdate: 'drmsessionupdate',
   Emsg: 'emsg',
   Error: 'error',
@@ -6047,6 +6474,7 @@ shaka.Player.EventName = {
   Loaded: 'loaded',
   Loading: 'loading',
   ManifestParsed: 'manifestparsed',
+  MediaQualityChanged: 'mediaqualitychanged',
   Metadata: 'metadata',
   OnStateChange: 'onstatechange',
   OnStateIdle: 'onstateidle',
@@ -6102,7 +6530,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v3.1.4-uncompiled';
+shaka.Player.version = 'v3.3.0-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.
@@ -6129,6 +6557,47 @@ shaka.Player.supportPlugins_ = {};
 shaka.Player.adManagerFactory_ = null;
 
 
+/**
+ * @const {!Object.<string, string>}
+ * @private
+ */
+shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_ = {
+  'mp4': 'video/mp4',
+  'm4v': 'video/mp4',
+  'm4a': 'audio/mp4',
+  'webm': 'video/webm',
+  'weba': 'audio/webm',
+  'mkv': 'video/webm', // Chromium browsers supports it.
+  'ts': 'video/mp2t',
+  'ogv': 'video/ogg',
+  'ogg': 'audio/ogg',
+  'mpg': 'video/mpeg',
+  'mpeg': 'video/mpeg',
+  'm3u8': 'application/x-mpegurl',
+  'mpd': 'application/dash+xml',
+  'mp3': 'audio/mpeg',
+  'aac': 'audio/aac',
+  'flac': 'audio/flac',
+  'wav': 'audio/wav',
+};
+
+
+/**
+ * @const {!Object.<string, string>}
+ * @private
+ */
+shaka.Player.TEXT_EXTENSIONS_TO_MIME_TYPES_ = {
+  'sbv': 'text/x-subviewer',
+  'srt': 'text/srt',
+  'vtt': 'text/vtt',
+  'webvtt': 'text/vtt',
+  'ttml': 'application/ttml+xml',
+  'lrc': 'application/x-subtitle-lrc',
+  'ssa': 'text/x-ssa',
+  'ass': 'text/x-ssa',
+};
+
+
 /**
  * @const {string}
  */