shaka-player 3.1.3 → 3.2.2

package/lib/player.js

@@ -217,6 +217,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
  */
 
@@ -596,7 +598,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       enterNode: (node, has, wants) => {
         this.dispatchEvent(this.makeEvent_(
             /* name= */ shaka.Player.EventName.OnStateChange,
-            /* data= */ {'state': node.name}));
+            /* data= */ (new Map()).set('state', node.name)));
 
         const action = actions.get(node);
         return action(has, wants);
@@ -627,7 +629,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       onIdle: (node) => {
         this.dispatchEvent(this.makeEvent_(
             /* name= */ shaka.Player.EventName.OnStateIdle,
-            /* data= */ {'state': node.name}));
+            /* data= */ (new Map()).set('state', node.name)));
       },
     };
 
@@ -647,7 +649,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
   /**
    * @param {!shaka.Player.EventName} name
-   * @param {Object=} data
+   * @param {Map.<string, Object>=} data
    * @return {!shaka.util.FakeEvent}
    * @private
    */
@@ -1142,24 +1144,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',
-        '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
@@ -1633,11 +1618,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
     });
 
-    // TODO (#1391): Once filterManifest_ is async, remove this eslint disable.
-    /* eslint-disable require-await */
     const playerInterface = {
       networkingEngine: networkingEngine,
-      filter: async (manifest) => this.filterManifest_(manifest),
+      filter: (manifest) => this.filterManifest_(manifest),
       makeTextStreamsForClosedCaptions: (manifest) => {
         return this.makeTextStreamsForClosedCaptions_(manifest);
       },
@@ -1655,7 +1638,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.configure('streaming.lowLatencyMode', true);
       },
     };
-    /* eslint-enable require-await */
 
     const startTime = Date.now() / 1000;
 
@@ -1747,17 +1729,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);
 
@@ -1872,7 +1848,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);
@@ -1911,7 +1891,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.
@@ -2024,6 +2005,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
@@ -2044,7 +2035,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,
@@ -2163,8 +2154,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_());
@@ -2337,13 +2342,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;
     }
@@ -2415,15 +2417,40 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     goog.asserts.assert(!endTime || startTime <= endTime,
         'Metadata start time should be less or equal to the end time!');
     const eventName = shaka.Player.EventName.Metadata;
-    const data = {
-      startTime: startTime,
-      endTime: endTime,
-      metadataType: metadataType,
-      payload: payload,
-    };
+    const data = new Map()
+        .set('startTime', startTime)
+        .set('endTime', endTime)
+        .set('metadataType', metadataType)
+        .set('payload', payload);
     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:
@@ -2869,6 +2896,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
@@ -3079,6 +3132,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
@@ -3103,6 +3169,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
@@ -3357,9 +3436,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)');
@@ -3599,36 +3680,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_();
@@ -3772,6 +3851,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.
@@ -3800,6 +3924,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.
@@ -4101,16 +4238,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(
@@ -4258,74 +4386,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 &&
@@ -4355,6 +4432,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_++,
@@ -4400,6 +4489,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 = 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
@@ -4424,10 +4645,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();
@@ -4438,7 +4660,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,
@@ -4680,8 +4902,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);
   }
 
@@ -4816,7 +5037,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Surface the buffering event so that the app knows if/when we are
     // buffering.
     const eventName = shaka.Player.EventName.Buffering;
-    this.dispatchEvent(this.makeEvent_(eventName, {'buffering': isBuffering}));
+    const data = (new Map()).set('buffering', isBuffering);
+    this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
   /**
@@ -4984,9 +5206,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 +5236,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 +5387,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);
   }
 
@@ -5198,10 +5427,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   onVariantChanged_(from, to) {
     // Delay the 'variantchanged' event so StreamingEngine has time to absorb
     // the changes before the user tries to query it.
-    const event = this.makeEvent_(shaka.Player.EventName.VariantChanged, {
-      oldTrack: from,
-      newTrack: to,
-    });
+    const data = new Map()
+        .set('oldTrack', from)
+        .set('newTrack', to);
+    const event = this.makeEvent_(shaka.Player.EventName.VariantChanged, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -5224,10 +5453,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
   /** @private */
   onAbrStatusChanged_() {
-    const event = this.makeEvent_(shaka.Player.EventName.AbrStatusChanged, {
-      newStatus: this.config_.abr.enabled,
-    });
-    this.delayDispatchEvent_(event);
+    const data = (new Map()).set('newStatus', this.config_.abr.enabled);
+    this.delayDispatchEvent_(this.makeEvent_(
+        shaka.Player.EventName.AbrStatusChanged, data));
   }
 
   /**
@@ -5244,7 +5472,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     const eventName = shaka.Player.EventName.Error;
-    const event = this.makeEvent_(eventName, {'detail': error});
+    const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
     this.dispatchEvent(event);
     if (event.defaultPrevented) {
       error.handled = true;
@@ -5273,7 +5501,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       eventElement: region.eventElement,
     };
 
-    this.dispatchEvent(this.makeEvent_(eventName, {detail: clone}));
+    const data = (new Map()).set('detail', clone);
+    this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
   /**
@@ -6102,7 +6331,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.3-uncompiled';
+shaka.Player.version = 'v3.2.2-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.
@@ -6129,6 +6358,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}
  */