shaka-player 4.8.3 → 4.8.5

package/externs/ima.js

@@ -204,6 +204,8 @@ google.ima.AdDisplayContainer = class {
   constructor(adContainer, video) {}
 
   initialize() {}
+
+  destroy() {}
 };
 
 

package/lib/ads/client_side_ad_manager.js

@@ -63,16 +63,17 @@ shaka.ads.ClientSideAdManager = class {
 
     google.ima.settings.setDisableCustomPlaybackForIOS10Plus(true);
 
-    const adDisplayContainer = new google.ima.AdDisplayContainer(
+    /** @private {!google.ima.AdDisplayContainer} */
+    this.adDisplayContainer_ = new google.ima.AdDisplayContainer(
         this.adContainer_,
         this.video_);
 
     // TODO: IMA: Must be done as the result of a user action on mobile
-    adDisplayContainer.initialize();
+    this.adDisplayContainer_.initialize();
 
     // IMA: This instance should be re-used for the entire lifecycle of
     // the page.
-    this.adsLoader_ = new google.ima.AdsLoader(adDisplayContainer);
+    this.adsLoader_ = new google.ima.AdsLoader(this.adDisplayContainer_);
 
     this.adsLoader_.getSettings().setPlayerType('shaka-player');
     this.adsLoader_.getSettings().setPlayerVersion(shaka.Player.version);
@@ -176,6 +177,7 @@ shaka.ads.ClientSideAdManager = class {
       this.imaAdsManager_.destroy();
     }
     this.adsLoader_.destroy();
+    this.adDisplayContainer_.destroy();
   }
 
   /**

package/lib/cea/cea_decoder.js

@@ -97,6 +97,7 @@ shaka.cea.CeaDecoder = class {
    * @override
    */
   clear() {
+    shaka.log.debug('Clearing CEA decoder');
     this.badFrames_ = 0;
     this.cea608DataArray_ = [];
     this.cea708DataArray_ = [];
@@ -113,6 +114,7 @@ shaka.cea.CeaDecoder = class {
    * Resets the decoder.
    */
   reset() {
+    shaka.log.debug('Resetting CEA decoder');
     this.currentField1Channel_ = 0;
     this.currentField2Channel_ = 0;
     for (const stream of this.cea608ModeToStream_.values()) {
@@ -128,6 +130,7 @@ shaka.cea.CeaDecoder = class {
    */
   extract(userDataSeiMessage, pts) {
     if (this.waitingForFirstPacket_) {
+      shaka.log.debug('Setting first pts value to', pts);
       for (const stream of this.cea608ModeToStream_.values()) {
         stream.firstPts(pts);
       }

package/lib/hls/hls_parser.js

@@ -928,13 +928,12 @@ shaka.hls.HlsParser = class {
     if (!playlist.segments.length) {
       return defaultBasicInfo;
     }
-    const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
-    const middleSegment = playlist.segments[middleSegmentIdx];
-    const middleSegmentUris = shaka.hls.Utils.constructSegmentUris(
+    const firstSegment = playlist.segments[0];
+    const firstSegmentUris = shaka.hls.Utils.constructSegmentUris(
         getUris(),
-        playlist.segments[0].verbatimSegmentUri);
-    const middleSegmentUri = middleSegmentUris[0];
-    const parsedUri = new goog.Uri(middleSegmentUri);
+        firstSegment.verbatimSegmentUri);
+    const firstSegmentUri = firstSegmentUris[0];
+    const parsedUri = new goog.Uri(firstSegmentUri);
     const extension = parsedUri.getPath().split('.').pop();
     const rawMimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
     if (rawMimeType) {
@@ -946,7 +945,7 @@ shaka.hls.HlsParser = class {
 
     let initData = null;
     const initSegmentRef = this.getInitSegmentReference_(
-        playlist, middleSegment.tags, getUris);
+        playlist, firstSegment.tags, getUris);
     this.mapTagToInitSegmentRefMap_.clear();
     if (initSegmentRef) {
       const initSegmentRequest = shaka.util.Networking.createSegmentRequest(
@@ -961,8 +960,17 @@ shaka.hls.HlsParser = class {
       initData = initResponse.data;
     }
 
-    const segmentRequest = shaka.net.NetworkingEngine.makeRequest(
-        middleSegmentUris, this.config_.retryParameters);
+    let startByte = 0;
+    let endByte = null;
+    const byterangeTag = shaka.hls.Utils.getFirstTagWithName(
+        firstSegment.tags, 'EXT-X-BYTERANGE');
+    if (byterangeTag) {
+      [startByte, endByte] = this.parseByteRange_(
+          /* previousReference= */ null, byterangeTag.value);
+    }
+
+    const segmentRequest = shaka.util.Networking.createSegmentRequest(
+        firstSegmentUris, startByte, endByte, this.config_.retryParameters);
     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
     const response = await this.makeNetworkRequest_(
         segmentRequest, requestType, {type});
@@ -980,7 +988,8 @@ shaka.hls.HlsParser = class {
         return basicInfo;
       }
     } else if (extension == 'mp4' || extension == 'cmfv' ||
-        extension == 'm4s' || contentMimeType == 'video/mp4' ||
+        extension == 'm4s' || extension == 'fmp4' ||
+        contentMimeType == 'video/mp4' ||
         contentMimeType == 'audio/mp4' ||
         contentMimeType == 'video/iso.segment') {
       const basicInfo = shaka.media.SegmentUtils.getBasicInfoFromMp4(

package/lib/media/closed_caption_parser.js

@@ -9,6 +9,7 @@ goog.provide('shaka.media.IClosedCaptionParser');
 
 goog.require('shaka.cea.DummyCaptionDecoder');
 goog.require('shaka.cea.DummyCeaParser');
+goog.require('shaka.log');
 goog.require('shaka.util.BufferUtils');
 
 
@@ -22,7 +23,8 @@ goog.require('shaka.util.BufferUtils');
  */
 shaka.media.IClosedCaptionParser = class {
   /**
-   * Initialize the caption parser. This should be called only once.
+   * Initialize the caption parser. This should be called whenever new init
+   * segment arrives.
    * @param {BufferSource} initSegment
    */
   init(initSegment) {}
@@ -88,6 +90,10 @@ shaka.media.ClosedCaptionParser = class {
    * @override
    */
   init(initSegment) {
+    shaka.log.debug('Passing new init segment to CEA parser');
+    // Reset underlying decoder when new init segment arrives
+    // to clear stored pts values.
+    this.reset();
     this.ceaParser_.init(initSegment);
   }
 

package/lib/media/media_source_engine.js

@@ -280,7 +280,7 @@ shaka.media.MediaSourceEngine = class {
         if (contentType == ContentType.VIDEO) {
           codecs = StreamUtils.getCorrectVideoCodecs(codecs);
         } else if (contentType == ContentType.AUDIO) {
-          codecs = StreamUtils.getCorrectAudioCodecs(codecs);
+          codecs = StreamUtils.getCorrectAudioCodecs(codecs, mimeType);
         }
         const extendedMimeType = MimeUtils.getExtendedType(
             stream, mimeType, codecs);
@@ -347,14 +347,11 @@ shaka.media.MediaSourceEngine = class {
 
     const support = {};
     for (const type of testMimeTypes) {
-      if (shaka.util.Platform.supportsMediaSource()) {
-        // Our TextEngine is only effective for MSE platforms at the moment.
-        if (shaka.text.TextEngine.isTypeSupported(type)) {
-          support[type] = true;
-        } else {
-          support[type] = shaka.media.Capabilities.isTypeSupported(type) ||
-                          shaka.transmuxer.TransmuxerEngine.isSupported(type);
-        }
+      if (shaka.text.TextEngine.isTypeSupported(type)) {
+        support[type] = true;
+      } else if (shaka.util.Platform.supportsMediaSource()) {
+        support[type] = shaka.media.Capabilities.isTypeSupported(type) ||
+                        shaka.transmuxer.TransmuxerEngine.isSupported(type);
       } else {
         support[type] = shaka.util.Platform.supportsMediaType(type);
       }

package/lib/media/segment_utils.js

@@ -470,7 +470,7 @@ shaka.media.SegmentUtils = class {
     if (!dolbyVision) {
       return codecs;
     }
-    const type = `video/mp4; codecs="${dolbyVision}"'`;
+    const type = `video/mp4; codecs="${dolbyVision}"`;
     if (shaka.media.Capabilities.isTypeSupported(type)) {
       return [dolbyVision];
     }

package/lib/player.js

@@ -715,6 +715,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.manifestFilterer_ = new shaka.media.ManifestFilterer(
         this.config_, this.maxHwRes_, null);
 
+    /** @private {!Array.<shaka.media.PreloadManager>} */
+    this.createdPreloadManagers_ = [];
+
     /** @private {shaka.util.Stats} */
     this.stats_ = null;
 
@@ -881,6 +884,18 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     await detachPromise;
 
+    // A PreloadManager can only be used with the Player instance that created
+    // it, so all PreloadManagers this Player has created are now useless.
+    // Destroy any remaining managers now, to help prevent memory leaks.
+    const preloadManagerDestroys = [];
+    for (const preloadManager of this.createdPreloadManagers_) {
+      if (!preloadManager.isDestroyed()) {
+        preloadManagerDestroys.push(preloadManager.destroy());
+      }
+    }
+    this.createdPreloadManagers_ = [];
+    await Promise.all(preloadManagerDestroys);
+
     // Tear-down the event managers to ensure handlers stop firing.
     if (this.globalEventManager_) {
       this.globalEventManager_.release();
@@ -1972,6 +1987,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     };
     preloadManager = new shaka.media.PreloadManager(
         assetUri, mimeType, startTimeOfLoad, startTime, playerInterface);
+    this.createdPreloadManagers_.push(preloadManager);
     return preloadManager;
   }
 
@@ -7201,7 +7217,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.8.3' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.8.5' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/media_capabilities.js

@@ -88,6 +88,7 @@ shaka.polyfill.MediaCapabilities = class {
    * @private
    */
   static async decodingInfo_(mediaDecodingConfig) {
+    /** @type {!MediaCapabilitiesDecodingInfo} */
     const res = {
       supported: false,
       powerEfficient: true,
@@ -96,60 +97,26 @@ shaka.polyfill.MediaCapabilities = class {
       configuration: mediaDecodingConfig,
     };
 
-    if (!mediaDecodingConfig) {
-      return res;
-    }
-
     const videoConfig = mediaDecodingConfig['video'];
     const audioConfig = mediaDecodingConfig['audio'];
 
-    const Capabilities = shaka.media.Capabilities;
-
     if (mediaDecodingConfig.type == 'media-source') {
       if (!shaka.util.Platform.supportsMediaSource()) {
         return res;
       }
-      // Use 'shaka.media.Capabilities.isTypeSupported'to check if
-      // the stream is supported.
-      // Cast platforms will additionally check canDisplayType(), which
-      // accepts extended MIME type parameters.
-      // See: https://github.com/shaka-project/shaka-player/issues/4726
+
       if (videoConfig) {
-        let isSupported;
-        if (shaka.util.Platform.isChromecast()) {
-          isSupported =
-              shaka.polyfill.MediaCapabilities.canCastDisplayType_(videoConfig);
-        } else if (shaka.util.Platform.isTizen()) {
-          let extendedType = videoConfig.contentType;
-          if (videoConfig.width && videoConfig.height) {
-            extendedType += `; width=${videoConfig.width}`;
-            extendedType += `; height=${videoConfig.height}`;
-          }
-          if (videoConfig.framerate) {
-            extendedType += `; framerate=${videoConfig.framerate}`;
-          }
-          if (videoConfig.bitrate) {
-            extendedType += `; bitrate=${videoConfig.bitrate}`;
-          }
-          isSupported = Capabilities.isTypeSupported(extendedType);
-        } else {
-          isSupported = Capabilities.isTypeSupported(videoConfig.contentType);
-        }
+        const isSupported =
+            await shaka.polyfill.MediaCapabilities.checkVideoSupport_(
+                videoConfig);
         if (!isSupported) {
           return res;
         }
       }
 
       if (audioConfig) {
-        let isSupported;
-        if (shaka.util.Platform.isChromecast() &&
-            audioConfig.spatialRendering) {
-          const extendedType =
-              audioConfig.contentType + '; spatialRendering=true';
-          isSupported = Capabilities.isTypeSupported(extendedType);
-        } else {
-          isSupported = Capabilities.isTypeSupported(audioConfig.contentType);
-        }
+        const isSupported =
+            shaka.polyfill.MediaCapabilities.checkAudioSupport_(audioConfig);
         if (!isSupported) {
           return res;
         }
@@ -178,122 +145,172 @@ shaka.polyfill.MediaCapabilities = class {
     if (!mediaDecodingConfig.keySystemConfiguration) {
       // The variant is supported if it's unencrypted.
       res.supported = true;
-      return Promise.resolve(res);
+      return res;
     } else {
-      // Get the MediaKeySystemAccess for the key system.
-      // Convert the MediaDecodingConfiguration object to a
-      // MediaKeySystemConfiguration object.
-
-      /** @type {MediaCapabilitiesKeySystemConfiguration} */
-      const mediaCapkeySystemConfig =
-          mediaDecodingConfig.keySystemConfiguration;
-      const audioCapabilities = [];
-      const videoCapabilities = [];
-
-      if (mediaCapkeySystemConfig.audio) {
-        let capability = {
-          robustness: mediaCapkeySystemConfig.audio.robustness || '',
-          contentType: mediaDecodingConfig.audio.contentType,
-        };
-
-        // Some Tizen devices seem to misreport AC-3 support, but correctly
-        // report EC-3 support. So query EC-3 as a fallback for AC-3.
-        // See https://github.com/shaka-project/shaka-player/issues/2989 for
-        // details.
-        if (shaka.util.Platform.isTizen() &&
-          mediaDecodingConfig.audio.contentType.includes('codecs="ac-3"')) {
-          capability = {
-            robustness: capability.robustness,
-            contentType: 'audio/mp4; codecs="ec-3"',
-          };
-        }
+      const mcapKeySystemConfig = mediaDecodingConfig.keySystemConfiguration;
+      const keySystemAccess =
+          await shaka.polyfill.MediaCapabilities.checkDrmSupport_(
+              videoConfig, audioConfig, mcapKeySystemConfig);
+      if (keySystemAccess) {
+        res.supported = true;
+        res.keySystemAccess = keySystemAccess;
+      }
+    }
 
-        if (mediaCapkeySystemConfig.audio.encryptionScheme) {
-          capability = {
-            robustness: capability.robustness,
-            contentType: capability.contentType,
-            encryptionScheme: mediaCapkeySystemConfig.audio.encryptionScheme,
-          };
-        }
+    return res;
+  }
 
-        audioCapabilities.push(capability);
+  /**
+   * @param {!VideoConfiguration} videoConfig The 'video' field of the
+   *   MediaDecodingConfiguration.
+   * @return {!Promise<boolean>}
+   * @private
+   */
+  static async checkVideoSupport_(videoConfig) {
+    // Use 'shaka.media.Capabilities.isTypeSupported' to check if
+    // the stream is supported.
+    // Cast platforms will additionally check canDisplayType(), which
+    // accepts extended MIME type parameters.
+    // See: https://github.com/shaka-project/shaka-player/issues/4726
+    if (shaka.util.Platform.isChromecast()) {
+      const isSupported =
+          await shaka.polyfill.MediaCapabilities.canCastDisplayType_(
+              videoConfig);
+      return isSupported;
+    } else if (shaka.util.Platform.isTizen()) {
+      let extendedType = videoConfig.contentType;
+      if (videoConfig.width && videoConfig.height) {
+        extendedType += `; width=${videoConfig.width}`;
+        extendedType += `; height=${videoConfig.height}`;
       }
-
-      if (mediaCapkeySystemConfig.video) {
-        let capability = {
-          robustness: mediaCapkeySystemConfig.video.robustness || '',
-          contentType: mediaDecodingConfig.video.contentType,
-        };
-        if (mediaCapkeySystemConfig.video.encryptionScheme) {
-          capability = {
-            robustness: capability.robustness,
-            contentType: capability.contentType,
-            encryptionScheme: mediaCapkeySystemConfig.video.encryptionScheme,
-          };
-        }
-        videoCapabilities.push(capability);
+      if (videoConfig.framerate) {
+        extendedType += `; framerate=${videoConfig.framerate}`;
+      }
+      if (videoConfig.bitrate) {
+        extendedType += `; bitrate=${videoConfig.bitrate}`;
       }
+      return shaka.media.Capabilities.isTypeSupported(extendedType);
+    }
+    return shaka.media.Capabilities.isTypeSupported(videoConfig.contentType);
+  }
+
+  /**
+   * @param {!AudioConfiguration} audioConfig The 'audio' field of the
+   *   MediaDecodingConfiguration.
+   * @return {boolean}
+   * @private
+   */
+  static checkAudioSupport_(audioConfig) {
+    let extendedType = audioConfig.contentType;
+    if (shaka.util.Platform.isChromecast() && audioConfig.spatialRendering) {
+      extendedType += '; spatialRendering=true';
+    }
+    return shaka.media.Capabilities.isTypeSupported(extendedType);
+  }
 
-      /** @type {MediaKeySystemConfiguration} */
-      const mediaKeySystemConfig = {
-        initDataTypes: [mediaCapkeySystemConfig.initDataType],
-        distinctiveIdentifier: mediaCapkeySystemConfig.distinctiveIdentifier,
-        persistentState: mediaCapkeySystemConfig.persistentState,
-        sessionTypes: mediaCapkeySystemConfig.sessionTypes,
+  /**
+   * @param {VideoConfiguration} videoConfig The 'video' field of the
+   *   MediaDecodingConfiguration.
+   * @param {AudioConfiguration} audioConfig The 'audio' field of the
+   *   MediaDecodingConfiguration.
+   * @param {!MediaCapabilitiesKeySystemConfiguration} mcapKeySystemConfig The
+   *   'keySystemConfiguration' field of the MediaDecodingConfiguration.
+   * @return {Promise<MediaKeySystemAccess>}
+   * @private
+   */
+  static async checkDrmSupport_(videoConfig, audioConfig, mcapKeySystemConfig) {
+    const audioCapabilities = [];
+    const videoCapabilities = [];
+
+    if (mcapKeySystemConfig.audio) {
+      const capability = {
+        robustness: mcapKeySystemConfig.audio.robustness || '',
+        contentType: audioConfig.contentType,
       };
 
-      // Only add the audio video capabilities if they have valid data.
-      // Otherwise the query will fail.
-      if (audioCapabilities.length) {
-        mediaKeySystemConfig.audioCapabilities = audioCapabilities;
+      // Some Tizen devices seem to misreport AC-3 support, but correctly
+      // report EC-3 support. So query EC-3 as a fallback for AC-3.
+      // See https://github.com/shaka-project/shaka-player/issues/2989 for
+      // details.
+      if (shaka.util.Platform.isTizen() &&
+          audioConfig.contentType.includes('codecs="ac-3"')) {
+        capability.contentType = 'audio/mp4; codecs="ec-3"';
       }
-      if (videoCapabilities.length) {
-        mediaKeySystemConfig.videoCapabilities = videoCapabilities;
+
+      if (mcapKeySystemConfig.audio.encryptionScheme) {
+        capability.encryptionScheme =
+            mcapKeySystemConfig.audio.encryptionScheme;
       }
 
-      const cacheKey = shaka.polyfill.MediaCapabilities
-          .generateKeySystemCacheKey_(
-              mediaDecodingConfig.video ?
-                  mediaDecodingConfig.video.contentType : '',
-              mediaDecodingConfig.audio ?
-                  mediaDecodingConfig.audio.contentType : '',
-              mediaDecodingConfig.keySystemConfiguration.keySystem);
-
-      let keySystemAccess;
-      try {
-        if (cacheKey in shaka.polyfill.MediaCapabilities
-            .memoizedMediaKeySystemAccessRequests_) {
-          keySystemAccess = shaka.polyfill.MediaCapabilities
-              .memoizedMediaKeySystemAccessRequests_[cacheKey];
-        } else {
-          keySystemAccess = await navigator.requestMediaKeySystemAccess(
-              mediaCapkeySystemConfig.keySystem, [mediaKeySystemConfig]);
-          shaka.polyfill.MediaCapabilities
-              .memoizedMediaKeySystemAccessRequests_[cacheKey] =
-                keySystemAccess;
-        }
-      } catch (e) {
-        shaka.log.info('navigator.requestMediaKeySystemAccess failed.');
+      audioCapabilities.push(capability);
+    }
+
+    if (mcapKeySystemConfig.video) {
+      const capability = {
+        robustness: mcapKeySystemConfig.video.robustness || '',
+        contentType: videoConfig.contentType,
+      };
+      if (mcapKeySystemConfig.video.encryptionScheme) {
+        capability.encryptionScheme =
+            mcapKeySystemConfig.video.encryptionScheme;
       }
+      videoCapabilities.push(capability);
+    }
 
-      if (keySystemAccess) {
-        res.supported = true;
-        res.keySystemAccess = keySystemAccess;
+    /** @type {MediaKeySystemConfiguration} */
+    const mediaKeySystemConfig = {
+      initDataTypes: [mcapKeySystemConfig.initDataType],
+      distinctiveIdentifier: mcapKeySystemConfig.distinctiveIdentifier,
+      persistentState: mcapKeySystemConfig.persistentState,
+      sessionTypes: mcapKeySystemConfig.sessionTypes,
+    };
+
+    // Only add audio / video capabilities if they have valid data.
+    // Otherwise the query will fail.
+    if (audioCapabilities.length) {
+      mediaKeySystemConfig.audioCapabilities = audioCapabilities;
+    }
+    if (videoCapabilities.length) {
+      mediaKeySystemConfig.videoCapabilities = videoCapabilities;
+    }
+
+    const cacheKey = shaka.polyfill.MediaCapabilities
+        .generateKeySystemCacheKey_(
+            videoConfig ? videoConfig.contentType : '',
+            audioConfig ? audioConfig.contentType : '',
+            mcapKeySystemConfig.keySystem);
+
+    /** @type {MediaKeySystemAccess} */
+    let keySystemAccess = null;
+    try {
+      if (cacheKey in shaka.polyfill.MediaCapabilities
+          .memoizedMediaKeySystemAccessRequests_) {
+        keySystemAccess = shaka.polyfill.MediaCapabilities
+            .memoizedMediaKeySystemAccessRequests_[cacheKey];
+      } else {
+        keySystemAccess = await navigator.requestMediaKeySystemAccess(
+            mcapKeySystemConfig.keySystem, [mediaKeySystemConfig]);
+        shaka.polyfill.MediaCapabilities
+            .memoizedMediaKeySystemAccessRequests_[cacheKey] =
+              keySystemAccess;
       }
+    } catch (e) {
+      shaka.log.info('navigator.requestMediaKeySystemAccess failed.');
     }
 
-    return res;
+    return keySystemAccess;
   }
 
   /**
    * Checks if the given media parameters of the video or audio streams are
    * supported by the Cast platform.
    * @param {!VideoConfiguration} videoConfig The 'video' field of the
-   *     MediaDecodingConfiguration.
-   * @return {boolean} `true` when the stream can be displayed on a Cast device.
+   *   MediaDecodingConfiguration.
+   * @return {!Promise<boolean>} `true` when the stream can be displayed on a
+   *   Cast device.
    * @private
    */
-  static canCastDisplayType_(videoConfig) {
+  static async canCastDisplayType_(videoConfig) {
     if (!(window.cast &&
         cast.__platform__ && cast.__platform__.canDisplayType)) {
       shaka.log.warning('Expected cast APIs to be available! Falling back to ' +
@@ -321,7 +338,7 @@ shaka.polyfill.MediaCapabilities = class {
       result = shaka.polyfill.MediaCapabilities
           .memoizedCanDisplayTypeRequests_[displayType];
     } else {
-      result = cast.__platform__.canDisplayType(displayType);
+      result = await cast.__platform__.canDisplayType(displayType);
       shaka.polyfill.MediaCapabilities
           .memoizedCanDisplayTypeRequests_[displayType] = result;
     }

package/lib/transmuxer/ts_transmuxer.js

@@ -22,6 +22,7 @@ goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4Generator');
+goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.TsParser');
 goog.require('shaka.util.Uint8ArrayUtils');
 
@@ -143,13 +144,17 @@ shaka.transmuxer.TsTransmuxer = class {
   convertCodecs(contentType, mimeType) {
     if (this.isTsContainer_(mimeType)) {
       const ContentType = shaka.util.ManifestParserUtils.ContentType;
+      const StreamUtils = shaka.util.StreamUtils;
       // The replace it's necessary because Firefox(the only browser that
       // supports MP3 in MP4) only support the MP3 codec with the mp3 string.
       // MediaSource.isTypeSupported('audio/mp4; codecs="mp4a.40.34"') -> false
       // MediaSource.isTypeSupported('audio/mp4; codecs="mp3"') -> true
       const codecs = shaka.util.MimeUtils.getCodecs(mimeType)
           .replace('mp4a.40.34', 'mp3').split(',')
-          .map(this.getCorrectVideoCodecs_).join(',');
+          .map((codecs) => {
+            return StreamUtils.getCorrectAudioCodecs(codecs, 'audio/mp4');
+          })
+          .map(StreamUtils.getCorrectVideoCodecs).join(',');
       if (contentType == ContentType.AUDIO) {
         return `audio/mp4; codecs="${codecs}"`;
       }
@@ -159,29 +164,6 @@ shaka.transmuxer.TsTransmuxer = class {
   }
 
 
-  /**
-   * @param {string} codec
-   * @return {string}
-   * @private
-   */
-  getCorrectVideoCodecs_(codec) {
-    if (codec.includes('avc1')) {
-      // Convert avc1 codec string from RFC-4281 to RFC-6381 for
-      // MediaSource.isTypeSupported
-      // Example, convert avc1.66.30 to avc1.42001e (0x42 == 66 and 0x1e == 30)
-      const avcdata = codec.split('.');
-      if (avcdata.length == 3) {
-        let result = avcdata.shift() + '.';
-        result += parseInt(avcdata.shift(), 10).toString(16);
-        result +=
-            ('000' + parseInt(avcdata.shift(), 10).toString(16)).slice(-4);
-        return result;
-      }
-    }
-    return codec;
-  }
-
-
   /**
    * @override
    * @export