shaka-player 3.3.3 → 3.3.6

package/lib/player.js

@@ -440,8 +440,23 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
      */
     this.isTextVisible_ = false;
 
-    /** @private {shaka.util.EventManager} */
-    this.eventManager_ = new shaka.util.EventManager();
+    /**
+     * For listeners scoped to the lifetime of the Player instance.
+     * @private {shaka.util.EventManager}
+     */
+    this.globalEventManager_ = new shaka.util.EventManager();
+
+    /**
+     * For listeners scoped to the lifetime of the media element attachment.
+     * @private {shaka.util.EventManager}
+     */
+    this.attachEventManager_ = new shaka.util.EventManager();
+
+    /**
+     * For listeners scoped to the lifetime of the loaded content.
+     * @private {shaka.util.EventManager}
+     */
+    this.loadEventManager_ = new shaka.util.EventManager();
 
     /** @private {shaka.net.NetworkingEngine} */
     this.networkingEngine_ = null;
@@ -582,7 +597,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // If the browser comes back online after being offline, then try to play
     // again.
-    this.eventManager_.listen(window, 'online', () => {
+    this.globalEventManager_.listen(window, 'online', () => {
       this.retryStreaming();
     });
 
@@ -770,10 +785,18 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     });
     await this.walker_.destroy();
 
-    // Tear-down the event manager to ensure messages stop moving around.
-    if (this.eventManager_) {
-      this.eventManager_.release();
-      this.eventManager_ = null;
+    // Tear-down the event managers to ensure handlers stop firing.
+    if (this.globalEventManager_) {
+      this.globalEventManager_.release();
+      this.globalEventManager_ = null;
+    }
+    if (this.attachEventManager_) {
+      this.attachEventManager_.release();
+      this.attachEventManager_ = null;
+    }
+    if (this.loadEventManager_) {
+      this.loadEventManager_.release();
+      this.loadEventManager_ = null;
     }
 
     this.abrManagerFactory_ = null;
@@ -1316,7 +1339,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       has.mediaElement = wants.mediaElement;
 
       const onError = (error) => this.onVideoError_(error);
-      this.eventManager_.listen(has.mediaElement, 'error', onError);
+      this.attachEventManager_.listen(has.mediaElement, 'error', onError);
     }
 
     this.video_ = has.mediaElement;
@@ -1343,10 +1366,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @private
    */
   onDetach_(has, wants) {
-    // If we are going from "detached" to "detached" we wouldn't have
+    // If we were going from "detached" to "detached" we wouldn't have
     // a media element to detach from.
     if (has.mediaElement) {
-      this.eventManager_.unlisten(has.mediaElement, 'error');
+      this.attachEventManager_.removeAll();
       has.mediaElement = null;
     }
 
@@ -1404,11 +1427,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // In most cases we should have a media element. The one exception would
     // be if there was an error and we, by chance, did not have a media element.
     if (has.mediaElement) {
-      this.eventManager_.unlisten(has.mediaElement, 'loadedmetadata');
-      this.eventManager_.unlisten(has.mediaElement, 'playing');
-      this.eventManager_.unlisten(has.mediaElement, 'pause');
-      this.eventManager_.unlisten(has.mediaElement, 'ended');
-      this.eventManager_.unlisten(has.mediaElement, 'ratechange');
+      this.loadEventManager_.removeAll();
     }
 
     // Some observers use some playback components, shutting down the observers
@@ -1902,18 +1921,18 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.assetUri_ = assetUri;
 
     this.playRateController_ = new shaka.media.PlayRateController({
-      getRate: () => has.mediaElement.playbackRate,
-      getDefaultRate: () => has.mediaElement.defaultPlaybackRate,
-      setRate: (rate) => { has.mediaElement.playbackRate = rate; },
-      movePlayhead: (delta) => { has.mediaElement.currentTime += delta; },
+      getRate: () => mediaElement.playbackRate,
+      getDefaultRate: () => mediaElement.defaultPlaybackRate,
+      setRate: (rate) => { mediaElement.playbackRate = rate; },
+      movePlayhead: (delta) => { mediaElement.currentTime += delta; },
     });
 
     const updateStateHistory = () => this.updateStateHistory_();
     const onRateChange = () => this.onRateChange_();
-    this.eventManager_.listen(mediaElement, 'playing', updateStateHistory);
-    this.eventManager_.listen(mediaElement, 'pause', updateStateHistory);
-    this.eventManager_.listen(mediaElement, 'ended', updateStateHistory);
-    this.eventManager_.listen(mediaElement, 'ratechange', onRateChange);
+    this.loadEventManager_.listen(mediaElement, 'playing', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'pause', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'ended', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'ratechange', onRateChange);
 
     const abrFactory = this.config_.abrFactory;
     if (!this.abrManager_ || this.abrManagerFactory_ != abrFactory) {
@@ -1976,6 +1995,24 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // "streaming" so that they can access internal information.
     this.loadMode_ = shaka.Player.LoadMode.MEDIA_SOURCE;
 
+    if (mediaElement.textTracks) {
+      this.loadEventManager_.listen(
+          mediaElement.textTracks, 'addtrack', (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 'chapters':
+                  this.activateChaptersTrack_(track);
+                  break;
+              }
+            }
+          });
+    }
+
     // The event must be fired after we filter by restrictions but before the
     // active stream is picked to allow those listening for the "streaming"
     // event to make changes before streaming starts.
@@ -2062,7 +2099,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     // Wait for the 'loadedmetadata' event to measure load() latency.
-    this.eventManager_.listenOnce(mediaElement, 'loadedmetadata', () => {
+    this.loadEventManager_.listenOnce(mediaElement, 'loadedmetadata', () => {
       const now = Date.now() / 1000;
       const delta = now - wants.startTimeOfLoad;
       this.stats_.setLoadLatency(delta);
@@ -2215,11 +2252,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Save the uri so that it can be used outside of the load-graph.
     this.assetUri_ = has.uri;
 
-    this.playhead_ = new shaka.media.SrcEqualsPlayhead(has.mediaElement);
+    const mediaElement = has.mediaElement;
+
+    this.playhead_ = new shaka.media.SrcEqualsPlayhead(mediaElement);
 
-    // This flag is used below in the language preference setup and
-    // track-management to check if this load was canceled before the necessary
-    // events fired.
+    // This flag is used below in the language preference setup to check if
+    // this load was canceled before the necessary awaits completed.
     let unloaded = false;
     this.cleanupOnUnload_.push(() => {
       unloaded = true;
@@ -2230,10 +2268,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     this.playRateController_ = new shaka.media.PlayRateController({
-      getRate: () => has.mediaElement.playbackRate,
-      getDefaultRate: () => has.mediaElement.defaultPlaybackRate,
-      setRate: (rate) => { has.mediaElement.playbackRate = rate; },
-      movePlayhead: (delta) => { has.mediaElement.currentTime += delta; },
+      getRate: () => mediaElement.playbackRate,
+      getDefaultRate: () => mediaElement.defaultPlaybackRate,
+      setRate: (rate) => { mediaElement.playbackRate = rate; },
+      movePlayhead: (delta) => { mediaElement.currentTime += delta; },
     });
 
     // We need to start the buffer management code near the end because it will
@@ -2245,17 +2283,17 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Add all media element listeners.
     const updateStateHistory = () => this.updateStateHistory_();
     const onRateChange = () => this.onRateChange_();
-    this.eventManager_.listen(has.mediaElement, 'playing', updateStateHistory);
-    this.eventManager_.listen(has.mediaElement, 'pause', updateStateHistory);
-    this.eventManager_.listen(has.mediaElement, 'ended', updateStateHistory);
-    this.eventManager_.listen(has.mediaElement, 'ratechange', onRateChange);
+    this.loadEventManager_.listen(mediaElement, 'playing', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'pause', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'ended', updateStateHistory);
+    this.loadEventManager_.listen(mediaElement, 'ratechange', onRateChange);
 
     // Wait for the 'loadedmetadata' event to measure load() latency, but only
     // if preload is set in a way that would result in this event firing
     // automatically.
     // See https://github.com/shaka-project/shaka-player/issues/2483
-    if (this.video_.preload != 'none') {
-      this.eventManager_.listenOnce(this.video_, 'loadedmetadata', () => {
+    if (mediaElement.preload != 'none') {
+      this.loadEventManager_.listenOnce(mediaElement, 'loadedmetadata', () => {
         const now = Date.now() / 1000;
         const delta = now - wants.startTimeOfLoad;
         this.stats_.setLoadLatency(delta);
@@ -2265,44 +2303,47 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // The audio tracks are only available on Safari at the moment, but this
     // drives the tracks API for Safari's native HLS. So when they change,
     // fire the corresponding Shaka Player event.
-    if (this.video_.audioTracks) {
-      this.eventManager_.listen(
-          this.video_.audioTracks, 'addtrack', () => this.onTracksChanged_());
-      this.eventManager_.listen(
-          this.video_.audioTracks, 'removetrack',
+    if (mediaElement.audioTracks) {
+      this.loadEventManager_.listen(
+          mediaElement.audioTracks, 'addtrack', () => this.onTracksChanged_());
+      this.loadEventManager_.listen(
+          mediaElement.audioTracks, 'removetrack',
           () => this.onTracksChanged_());
-      this.eventManager_.listen(
-          this.video_.audioTracks, 'change', () => this.onTracksChanged_());
-    }
-    if (this.video_.textTracks) {
-      this.eventManager_.listen(this.video_.textTracks, 'addtrack', (e) => {
-        // If we have moved on to another piece of content while waiting for
-        // the above event, we should not process tracks here.
-        if (unloaded) {
-          return;
-        }
+      this.loadEventManager_.listen(
+          mediaElement.audioTracks, 'change', () => this.onTracksChanged_());
+    }
+
+    if (mediaElement.textTracks) {
+      this.loadEventManager_.listen(
+          mediaElement.textTracks, 'addtrack', (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.activateChaptersTrack_(track);
+                  break;
+
+                default:
+                  this.onTracksChanged_();
+                  break;
+              }
+            }
+          });
 
-        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_());
-      this.eventManager_.listen(
-          this.video_.textTracks, 'change', () => this.onTracksChanged_());
+      this.loadEventManager_.listen(
+          mediaElement.textTracks, 'removetrack',
+          () => this.onTracksChanged_());
+      this.loadEventManager_.listen(
+          mediaElement.textTracks, 'change',
+          () => this.onTracksChanged_());
     }
 
     const extension = shaka.media.ManifestParser.getExtension(has.uri);
@@ -2311,14 +2352,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // 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 = this.cmcdManager_.appendSrcData(has.uri, mimeType);
+    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
     // other platforms by triggering unbounded loading of media data, but is
     // necessary here.
     if (shaka.util.Platform.isTizen() || shaka.util.Platform.isWebOS()) {
-      has.mediaElement.load();
+      mediaElement.load();
     }
 
     // Set the load mode last so that we know that all our components are
@@ -2334,24 +2375,18 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // wait for the full data, that won't happen on Safari until the play button
     // is hit.
     const fullyLoaded = new shaka.util.PublicPromise();
-    shaka.util.MediaReadyState.waitForReadyState(this.video_,
+    shaka.util.MediaReadyState.waitForReadyState(mediaElement,
         HTMLMediaElement.HAVE_METADATA,
-        this.eventManager_,
+        this.loadEventManager_,
         () => {
           fullyLoaded.resolve();
         });
 
     // We can't switch to preferred languages, though, until the data is loaded.
-    shaka.util.MediaReadyState.waitForReadyState(this.video_,
+    shaka.util.MediaReadyState.waitForReadyState(mediaElement,
         HTMLMediaElement.HAVE_CURRENT_DATA,
-        this.eventManager_,
+        this.loadEventManager_,
         async () => {
-          // If we have moved on to another piece of content while waiting for
-          // the above event, we should not change tracks here.
-          if (unloaded) {
-            return;
-          }
-
           this.setupPreferredAudioOnSrc_();
 
           // Applying the text preference too soon can result in it being
@@ -2359,8 +2394,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           const textTracks = this.getFilteredTextTracks_();
           if (!textTracks.find((t) => t.mode != 'disabled')) {
             await new Promise((resolve) => {
-              this.eventManager_.listenOnce(
-                  this.video_.textTracks, 'change', resolve);
+              this.loadEventManager_.listenOnce(
+                  mediaElement.textTracks, 'change', resolve);
+
               // We expect the event to fire because it does on Safari.
               // But in case it doesn't on some other platform or future
               // version, move on in 1 second no matter what.  This keeps the
@@ -2379,10 +2415,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           this.setupPreferredTextOnSrc_();
         });
 
-    if (this.video_.error) {
+    if (mediaElement.error) {
       // Already failed!
       fullyLoaded.reject(this.videoErrorToShakaError_());
-    } else if (this.video_.preload == 'none') {
+    } else if (mediaElement.preload == 'none') {
       shaka.log.alwaysWarn(
           'With <video preload="none">, the browser will not load anything ' +
           'until play() is called. We are unable to measure load latency in ' +
@@ -2393,7 +2429,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       fullyLoaded.resolve();
     }
 
-    this.eventManager_.listenOnce(this.video_, 'error', () => {
+    this.loadEventManager_.listenOnce(mediaElement, 'error', () => {
       fullyLoaded.reject(this.videoErrorToShakaError_());
     });
 
@@ -2477,7 +2513,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // Hidden mode is required for the cuechange event to launch correctly
     track.mode = 'hidden';
-    this.eventManager_.listen(track, 'cuechange', () => {
+    this.loadEventManager_.listen(track, 'cuechange', () => {
       if (!track.activeCues) {
         return;
       }
@@ -2555,12 +2591,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * We're looking for chapters tracks to process the chapters.
+   * Set the mode on a chapters track so that it loads.
    *
    * @param {?TextTrack} track
    * @private
    */
-  processChaptersTrack_(track) {
+  activateChaptersTrack_(track) {
     if (!track || track.kind != 'chapters') {
       return;
     }
@@ -2573,10 +2609,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // this process to be repeated several times to ensure that it has been put
     // in the correct mode.
     const timer = new shaka.util.Timer(() => {
-      const chaptersTracks = this.getChaptersTracks_();
-      for (const chaptersTrack of chaptersTracks) {
-        chaptersTrack.mode = 'hidden';
-      }
+      track.mode = 'hidden';
     }).tickNow().tickAfter(0.5);
 
     this.cleanupOnUnload_.push(() => {
@@ -4721,25 +4754,41 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     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);
+
+    /** @type {!HTMLTrackElement} */
+    const trackElement = 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);
-      }
+      await new Promise((resolve, reject) => {
+        // The chapter data isn't available until the 'load' event fires, and
+        // that won't happen until the chapters track is activated by the
+        // activateChaptersTrack_ method.
+        this.loadEventManager_.listenOnce(trackElement, 'load', resolve);
+        this.loadEventManager_.listenOnce(trackElement, 'error', (event) => {
+          reject(new shaka.util.Error(
+              shaka.util.Error.Severity.RECOVERABLE,
+              shaka.util.Error.Category.TEXT,
+              shaka.util.Error.Code.CHAPTERS_TRACK_FAILED));
+        });
+      });
+
       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=');
@@ -4793,6 +4842,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @param {string} mimeType
    * @param {string} label
    * @param {!Array.<!shaka.extern.AdCuePoint>} adCuePoints
+   * @return {!Promise.<!HTMLTrackElement>}
    * @private
    */
   async addSrcTrackElement_(uri, language, kind, mimeType, label,
@@ -4808,12 +4858,14 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       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
@@ -4823,7 +4875,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!this.video_.getAttribute('crossorigin')) {
       this.video_.setAttribute('crossorigin', 'anonymous');
     }
+
     this.video_.appendChild(trackElement);
+    return trackElement;
   }
 
   /**
@@ -5193,7 +5247,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
 
       await stream.createSegmentIndex();
-      const ref = stream.segmentIndex[Symbol.iterator]().seek(time);
+      const iter = stream.segmentIndex.getIteratorForTime(time);
+      const ref = iter ? iter.next().value : null;
       if (!ref) {
         return null;
       }
@@ -5862,7 +5917,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }  // if (keyIds.size)
 
     if (tracksChanged) {
-      this.updateAbrManagerVariants_();
+      const variantsUpdated = this.updateAbrManagerVariants_();
+      if (!variantsUpdated) {
+        return;
+      }
     }
 
     const currentVariant = this.streamingEngine_.getCurrentVariant();
@@ -6576,7 +6634,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v3.3.3-uncompiled';
+shaka.Player.version = 'v3.3.6-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/util/config_utils.js

@@ -127,4 +127,29 @@ shaka.util.ConfigUtils = class {
     last[fieldName.substring(nameStart).replace(/\\\./g, '.')] = value;
     return configObject;
   }
+
+  /**
+   * Reference the input parameters so the compiler doesn't remove them from
+   * the calling function.  Return whatever value is specified.
+   *
+   * This allows an empty or default implementation of a config callback that
+   * still bears the complete function signature even in compiled mode.
+   *
+   * The caller should look something like this:
+   *
+   *   const callback = (a, b, c, d) => {
+   *     return referenceParametersAndReturn(
+             [a, b, c, d],
+             a);  // Can be anything, doesn't need to be one of the parameters
+   *   };
+   *
+   * @param {!Array.<?>} parameters
+   * @param {T} returnValue
+   * @return {T}
+   * @template T
+   * @noinline
+   */
+  static referenceParametersAndReturn(parameters, returnValue) {
+    return parameters && returnValue;
+  }
 };

package/lib/util/error.js

@@ -345,6 +345,13 @@ shaka.util.Error.Code = {
    */
   'MISSING_TEXT_PLUGIN': 2014,
 
+  /**
+   * The chapters track failed to load.  The browser does not provide any
+   * information in this case to identify why it failed, but there may be
+   * details in the JavaScript console.
+   */
+  'CHAPTERS_TRACK_FAILED': 2015,
+
   /**
    * Some component tried to read past the end of a buffer.  The segment index,
    * init segment, or PSSH may be malformed.

package/lib/util/manifest_parser_utils.js

@@ -167,7 +167,7 @@ shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_ = [
   /^hev/,
   /^hvc/,
   /^vp0?[89]/,
-  /^av1$/,
+  /^av01/,
 ];
 
 

package/lib/util/mime_utils.js

@@ -8,6 +8,7 @@ goog.provide('shaka.util.MimeUtils');
 
 goog.require('shaka.dependencies');
 goog.require('shaka.media.Transmuxer');
+goog.require('shaka.util.ManifestParserUtils');
 
 /**
  * @summary A set of utility functions for dealing with MIME types.
@@ -32,6 +33,8 @@ shaka.util.MimeUtils = class {
   /**
    * Takes a MIME type and a codecs string and produces the full MIME
    * type. If it's a transport stream, convert its codecs to MP4 codecs.
+   * Otherwise for multiplexed content, convert the video MIME types to
+   * their audio equivalents if the content type is audio.
    *
    * @param {string} mimeType
    * @param {string} codecs
@@ -40,13 +43,19 @@ shaka.util.MimeUtils = class {
    */
   static getFullOrConvertedType(mimeType, codecs, contentType) {
     const fullMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    if (!shaka.dependencies.muxjs() ||
-        !shaka.media.Transmuxer.isTsContainer(fullMimeType)) {
-      return fullMimeType;
+    if (shaka.media.Transmuxer.isTsContainer(fullMimeType)) {
+      if (shaka.dependencies.muxjs()) {
+        return shaka.media.Transmuxer.convertTsCodecs(
+            contentType, fullMimeType);
+      }
+    } else if (contentType == ContentType.AUDIO) {
+      // video/mp2t is the correct mime type for TS audio, so only replace the
+      // word "video" with "audio" for non-TS audio content.
+      return fullMimeType.replace('video', 'audio');
     }
-
-    return shaka.media.Transmuxer.convertTsCodecs(contentType, fullMimeType);
+    return fullMimeType;
   }
 
 
@@ -94,6 +103,53 @@ shaka.util.MimeUtils = class {
     return codecs.split(',');
   }
 
+  /**
+   * Get the normalized codec from a codec string,
+   * independently of their container.
+   *
+   * @param {string} codecString
+   * @return {string}
+   */
+  static getNormalizedCodec(codecString) {
+    const parts =
+      shaka.util.MimeUtils.getCodecParts_(codecString);
+    const base = parts[0];
+    const profile = parts[1].toLowerCase();
+    switch (true) {
+      case base === 'mp4a' && profile === '69':
+      case base === 'mp4a' && profile === '6b':
+        return 'mp3';
+      case base === 'mp4a' && profile === '66':
+      case base === 'mp4a' && profile === '67':
+      case base === 'mp4a' && profile === '68':
+      case base === 'mp4a' && profile === '40.2':
+      case base === 'mp4a' && profile === '40.02':
+      case base === 'mp4a' && profile === '40.5':
+      case base === 'mp4a' && profile === '40.05':
+      case base === 'mp4a' && profile === '40.29':
+      case base === 'mp4a' && profile === '40.42': // Extended HE-AAC
+        return 'aac';
+      case base === 'mp4a' && profile === 'a5':
+        return 'ac-3'; // Dolby Digital
+      case base === 'mp4a' && profile === 'a6':
+        return 'ec-3'; // Dolby Digital Plus
+      case base === 'mp4a' && profile === 'b2':
+        return 'dtsx'; // DTS:X
+      case base === 'mp4a' && profile === 'a9':
+        return 'dtsc'; // DTS Digital Surround
+      case base === 'avc1':
+      case base === 'avc3':
+        return 'avc'; // H264
+      case base === 'hvc1':
+      case base === 'hev1':
+        return 'hevc'; // H265
+      case base === 'dvh1':
+      case base === 'dvhe':
+        return 'dovi'; // Dolby Vision
+    }
+    return base;
+  }
+
   /**
    * Get the base codec from a codec string.
    *
@@ -150,7 +206,7 @@ shaka.util.MimeUtils = class {
 
     const base = parts[0];
 
-    parts.pop();
+    parts.shift();
     const profile = parts.join('.');
 
     // Make sure that we always return a "base" and "profile".