shaka-player 4.7.12 → 4.7.14

package/externs/shaka/manifest.js

@@ -400,7 +400,8 @@ shaka.extern.FetchCryptoKeysFunction;
  *      undefined),
  *   mssPrivateData: (shaka.extern.MssPrivateData|undefined),
  *   external: boolean,
- *   fastSwitching: boolean
+ *   fastSwitching: boolean,
+ *   fullMimeTypes: !Set.<string>
  * }}
  *
  * @description
@@ -430,10 +431,14 @@ shaka.extern.FetchCryptoKeysFunction;
  * @property {string} mimeType
  *   <i>Required.</i> <br>
  *   The Stream's MIME type, e.g., 'audio/mp4', 'video/webm', or 'text/vtt'.
+ *   In the case of a stream that adapts between different periods with
+ *   different MIME types, this represents only the first period.
  * @property {string} codecs
  *   <i>Defaults to '' (i.e., unknown / not needed).</i> <br>
  *   The Stream's codecs, e.g., 'avc1.4d4015' or 'vp9', which must be
  *   compatible with the Stream's MIME type. <br>
+ *   In the case of a stream that adapts between different periods with
+ *   different codecs, this represents only the first period.
  *   See {@link https://tools.ietf.org/html/rfc6381}
  * @property {(number|undefined)} frameRate
  *   <i>Video streams only.</i> <br>
@@ -535,6 +540,11 @@ shaka.extern.FetchCryptoKeysFunction;
  *   Eg: external text tracks.
  * @property {boolean} fastSwitching
  *   Indicate if the stream should be used for fast switching.
+ * @property {!Set.<string>} fullMimeTypes
+ *   A set of full MIME types (e.g. MIME types plus codecs information), that
+ *   represents the types used in each period of the original manifest.
+ *   Meant for being used by compatibility checking, such as with
+ *   MediaSource.isTypeSupported.
  *
  * @exportDoc
  */

package/externs/shaka/offline.js

@@ -230,7 +230,9 @@ shaka.extern.StreamDB;
  *   tilesLayout: ?string,
  *   pendingSegmentRefId: (string|undefined),
  *   pendingInitSegmentRefId: (string|undefined),
- *   dataKey: number
+ *   dataKey: number,
+ *   mimeType: ?string,
+ *   codecs: ?string
  * }}
  *
  * @property {?number} initSegmentKey
@@ -263,6 +265,10 @@ shaka.extern.StreamDB;
  *   downloaded.
  * @property {number} dataKey
  *   The key to the data in storage.
+ * @property {?string} mimeType
+ *   The mimeType of the segment.
+ * @property {?string} codecs
+ *   The codecs of the segment.
  */
 shaka.extern.SegmentDB;
 

package/lib/ads/client_side_ad_manager.js

@@ -533,7 +533,9 @@ shaka.ads.ClientSideAdManager = class {
         shaka.ads.AdManager.AD_STARTED, data));
     if (this.ad_.isLinear()) {
       this.adContainer_.setAttribute('ad-active', 'true');
-      this.video_.pause();
+      if (!this.config_.customPlayheadTracker) {
+        this.video_.pause();
+      }
       if (this.video_.muted) {
         this.ad_.setInitialMuted(this.video_.volume);
       } else {
@@ -551,7 +553,7 @@ shaka.ads.ClientSideAdManager = class {
         (new Map()).set('originalEvent', e)));
     if (this.ad_ && this.ad_.isLinear()) {
       this.adContainer_.removeAttribute('ad-active');
-      if (!this.video_.ended) {
+      if (!this.config_.customPlayheadTracker && !this.video_.ended) {
         this.video_.play();
       }
     }

package/lib/dash/dash_parser.js

@@ -1485,8 +1485,13 @@ shaka.dash.DashParser = class {
         const getBaseUris = context.representation.getBaseUris;
         streamInfo = {
           generateSegmentIndex: () => {
-            return Promise.resolve(shaka.media.SegmentIndex.forSingleSegment(
-                periodStart, duration, getBaseUris()));
+            const segmentIndex = shaka.media.SegmentIndex.forSingleSegment(
+                periodStart, duration, getBaseUris());
+            segmentIndex.forEachTopLevelReference((ref) => {
+              ref.mimeType = context.representation.mimeType;
+              ref.codecs = context.representation.codecs;
+            });
+            return Promise.resolve(segmentIndex);
           },
         };
       }
@@ -1585,7 +1590,7 @@ shaka.dash.DashParser = class {
         },
         segmentIndex: null,
         mimeType: context.representation.mimeType,
-        codecs: context.representation.codecs,
+        codecs,
         frameRate: context.representation.frameRate,
         pixelAspectRatio: context.representation.pixelAspectRatio,
         bandwidth: context.bandwidth,
@@ -1615,6 +1620,8 @@ shaka.dash.DashParser = class {
         accessibilityPurpose,
         external: false,
         fastSwitching: false,
+        fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+            context.representation.mimeType, context.representation.codecs)]),
       };
     }
 

package/lib/dash/segment_base.js

@@ -62,7 +62,7 @@ shaka.dash.SegmentBase = class {
 
     const getUris = () => resolvedUris;
     const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
-    return new shaka.media.InitSegmentReference(
+    const ref = new shaka.media.InitSegmentReference(
         getUris,
         startByte,
         endByte,
@@ -70,6 +70,9 @@ shaka.dash.SegmentBase = class {
         /* timescale= */ null,
         /* segmentData= */ null,
         aes128Key);
+    ref.codecs = context.representation.codecs;
+    ref.mimeType = context.representation.mimeType;
+    return ref;
   }
 
   /**
@@ -184,6 +187,10 @@ shaka.dash.SegmentBase = class {
           indexData, initData, uris, initSegmentReference, timestampOffset,
           appendWindowStart, appendWindowEnd);
     }
+    for (const ref of references) {
+      ref.codecs = context.representation.codecs;
+      ref.mimeType = context.representation.mimeType;
+    }
 
     presentationTimeline.notifySegments(references);
 

package/lib/dash/segment_list.js

@@ -60,7 +60,8 @@ shaka.dash.SegmentList = class {
     const references = SegmentList.createSegmentReferences_(
         context.periodInfo.start, context.periodInfo.duration,
         info.startNumber, context.representation.getBaseUris, info,
-        initSegmentReference, aes128Key);
+        initSegmentReference, aes128Key, context.representation.mimeType,
+        context.representation.codecs);
 
     const isNew = !segmentIndex;
     if (segmentIndex) {
@@ -199,12 +200,14 @@ shaka.dash.SegmentList = class {
    * @param {shaka.dash.SegmentList.SegmentListInfo} info
    * @param {shaka.media.InitSegmentReference} initSegmentReference
    * @param {shaka.extern.aes128Key|undefined} aes128Key
+   * @param {string} mimeType
+   * @param {string} codecs
    * @return {!Array.<!shaka.media.SegmentReference>}
    * @private
    */
   static createSegmentReferences_(
       periodStart, periodDuration, startNumber, getBaseUris, info,
-      initSegmentReference, aes128Key) {
+      initSegmentReference, aes128Key, mimeType, codecs) {
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
 
     let max = info.mediaSegments.length;
@@ -251,22 +254,25 @@ shaka.dash.SegmentList = class {
         }
         return uris;
       };
-      references.push(
-          new shaka.media.SegmentReference(
-              periodStart + startTime,
-              periodStart + endTime,
-              getUris,
-              segment.start,
-              segment.end,
-              initSegmentReference,
-              timestampOffset,
-              appendWindowStart, appendWindowEnd,
-              /* partialReferences= */ [],
-              /* tilesLayout= */ '',
-              /* tileDuration= */ null,
-              /* syncTime= */ null,
-              shaka.media.SegmentReference.Status.AVAILABLE,
-              aes128Key));
+
+      const ref = new shaka.media.SegmentReference(
+          periodStart + startTime,
+          periodStart + endTime,
+          getUris,
+          segment.start,
+          segment.end,
+          initSegmentReference,
+          timestampOffset,
+          appendWindowStart, appendWindowEnd,
+          /* partialReferences= */ [],
+          /* tilesLayout= */ '',
+          /* tileDuration= */ null,
+          /* syncTime= */ null,
+          shaka.media.SegmentReference.Status.AVAILABLE,
+          aes128Key);
+      ref.codecs = codecs;
+      ref.mimeType = mimeType;
+      references.push(ref);
       prevEndTime = endTime;
     }
 

package/lib/dash/segment_template.js

@@ -213,6 +213,8 @@ shaka.dash.SegmentTemplate = class {
       timeline: segmentInfo.timeline,
       mediaTemplate: media,
       indexTemplate: index,
+      mimeType: context.representation.mimeType,
+      codecs: context.representation.codecs,
     };
   }
 
@@ -392,6 +394,11 @@ shaka.dash.SegmentTemplate = class {
         Math.ceil(availablePeriodTimes[1] / segmentDuration) - 1,
       ];
 
+      // For Low Latency we can request the partial current position.
+      if (context.representation.availabilityTimeOffset) {
+        availablePeriodPositions[1]++;
+      }
+
       // In absolute positions.
       const availablePresentationPositions =
           availablePeriodPositions.map((x) => x + startNumber);
@@ -463,6 +470,8 @@ shaka.dash.SegmentTemplate = class {
           /* syncTime= */ null,
           shaka.media.SegmentReference.Status.AVAILABLE,
           aes128Key);
+      ref.codecs = context.representation.codecs;
+      ref.mimeType = context.representation.mimeType;
       // This is necessary information for thumbnail streams:
       ref.trueEndTime = trueSegmentEnd;
       return ref;
@@ -552,7 +561,7 @@ shaka.dash.SegmentTemplate = class {
       return resolvedUris;
     };
     const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
-    return new shaka.media.InitSegmentReference(
+    const ref = new shaka.media.InitSegmentReference(
         getUris,
         /* startByte= */ 0,
         /* endByte= */ null,
@@ -560,6 +569,9 @@ shaka.dash.SegmentTemplate = class {
         /* timescale= */ null,
         /* segmentData= */ null,
         aes128Key);
+    ref.codecs = context.representation.codecs;
+    ref.mimeType = context.representation.mimeType;
+    return ref;
   }
 };
 
@@ -689,7 +701,7 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
    */
   appendTemplateInfo(info, periodStart, periodEnd, shouldFit,
       initSegmentReference) {
-    this.initSegmentReference_ = initSegmentReference;
+    this.updateInitSegmentReference(initSegmentReference);
     if (!this.templateInfo_) {
       this.templateInfo_ = info;
       this.periodStart_ = periodStart;
@@ -720,6 +732,24 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
     }
   }
 
+  /**
+   * Updates the init segment reference and propagates the update to all
+   * references.
+   * @param {shaka.media.InitSegmentReference} initSegmentReference
+   */
+  updateInitSegmentReference(initSegmentReference) {
+    if (this.initSegmentReference_ === initSegmentReference) {
+      return;
+    }
+
+    this.initSegmentReference_ = initSegmentReference;
+    for (const reference of this.references) {
+      if (reference) {
+        reference.updateInitSegmentReference(initSegmentReference);
+      }
+    }
+  }
+
   /**
    *
    * @param {number} time
@@ -835,6 +865,8 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
           this.periodEnd_ !== Infinity) {
         segmentEnd = this.periodEnd_;
       }
+      const codecs = this.templateInfo_.codecs;
+      const mimeType = this.templateInfo_.mimeType;
 
       const partialSegmentRefs = [];
 
@@ -877,6 +909,8 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
             /* syncTime= */ null,
             shaka.media.SegmentReference.Status.AVAILABLE,
             this.aes128Key_);
+        partial.codecs = codecs;
+        partial.mimeType = mimeType;
         if (this.segmentSequenceCadence_ == 0) {
           if (i > 0) {
             partial.markAsNonIndependent();
@@ -920,6 +954,8 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
           shaka.media.SegmentReference.Status.AVAILABLE,
           this.aes128Key_,
           /* allPartialSegments= */ range.partialSegments > 0);
+      ref.codecs = codecs;
+      ref.mimeType = mimeType;
       ref.trueEndTime = trueSegmentEnd;
       this.references[correctedPosition] = ref;
     }
@@ -955,7 +991,9 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
  *   unscaledPresentationTimeOffset: number,
  *   timeline: Array.<shaka.media.PresentationTimeline.TimeRange>,
  *   mediaTemplate: ?string,
- *   indexTemplate: ?string
+ *   indexTemplate: ?string,
+ *   mimeType: string,
+ *   codecs: string
  * }}
  *
  * @description
@@ -977,5 +1015,9 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
  *   The media URI template, if given.
  * @property {?string} indexTemplate
  *   The index URI template, if given.
+ * @property {string} mimeType
+ *   The mimeType.
+ * @property {string} codecs
+ *   The codecs.
  */
 shaka.dash.SegmentTemplate.SegmentTemplateInfo;

package/lib/hls/hls_parser.js

@@ -1224,6 +1224,7 @@ shaka.hls.HlsParser = class {
             textStreamInfo.stream.mimeType =
                 this.guessMimeTypeBeforeLoading_(type, codecs) ||
                 this.guessMimeTypeFallback_(type);
+            this.setFullTypeForStream_(textStreamInfo.stream);
           }
         }
       }
@@ -1233,6 +1234,15 @@ shaka.hls.HlsParser = class {
     return textStreams.filter((s) => s);
   }
 
+  /**
+   * @param {!shaka.extern.Stream} stream
+   * @private
+   */
+  setFullTypeForStream_(stream) {
+    stream.fullMimeTypes = new Set([shaka.util.MimeUtils.getFullType(
+        stream.mimeType, stream.codecs)]);
+  }
+
   /**
    * @param {!Array.<!shaka.hls.Tag>} imageTags from the playlist.
    * @param {!Array.<!shaka.hls.Tag>} iFrameTags from the playlist.
@@ -2266,6 +2276,7 @@ shaka.hls.HlsParser = class {
       stream.mimeType = realStream.mimeType;
       stream.bandwidth = stream.bandwidth || realStream.bandwidth;
       stream.codecs = stream.codecs || realStream.codecs;
+      this.setFullTypeForStream_(stream);
 
       // Since we lazy-loaded this content, the player may need to create new
       // sessions for the DRM info in this stream.
@@ -2280,6 +2291,7 @@ shaka.hls.HlsParser = class {
             // To aid manifest filtering, assume before loading that all video
             // renditions have the same MIME type.  (And likewise for audio.)
             otherStreamInfo.stream.mimeType = realStream.mimeType;
+            this.setFullTypeForStream_(otherStreamInfo.stream);
           }
         }
       }
@@ -2288,6 +2300,7 @@ shaka.hls.HlsParser = class {
         const firstSegment = realStream.segmentIndex.get(0);
         if (firstSegment && firstSegment.initSegmentReference) {
           stream.mimeType = 'application/mp4';
+          this.setFullTypeForStream_(stream);
         }
       }
 
@@ -2537,6 +2550,7 @@ shaka.hls.HlsParser = class {
     stream.drmInfos = drmInfos;
     stream.keyIds = keyIds;
     stream.mimeType = mimeType;
+    this.setFullTypeForStream_(stream);
 
     const mediaSequenceToStartTime = this.isLive_() ?
         this.mediaSequenceToStartTimeByType_.get(type) : new Map();
@@ -2692,7 +2706,7 @@ shaka.hls.HlsParser = class {
       roles.push(shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE);
     }
 
-    return {
+    const stream = {
       id: this.globalId_++,
       originalId: name,
       groupId: null,
@@ -2730,7 +2744,10 @@ shaka.hls.HlsParser = class {
       accessibilityPurpose: accessibilityPurpose,
       external: false,
       fastSwitching: false,
+      fullMimeTypes: new Set(),
     };
+    this.setFullTypeForStream_(stream);
+    return stream;
   }
 
   /**

package/lib/media/drm_engine.js

@@ -1551,6 +1551,9 @@ shaka.media.DrmEngine = class {
       const req = this.playerInterface_.netEngine.request(requestType, request);
       response = await req.promise;
     } catch (error) {
+      if (this.destroyer_.destroyed()) {
+        return;
+      }
       // Request failed!
       goog.asserts.assert(error instanceof shaka.util.Error,
           'Wrong NetworkingEngine error type!');
@@ -1559,9 +1562,20 @@ shaka.media.DrmEngine = class {
           shaka.util.Error.Category.DRM,
           shaka.util.Error.Code.LICENSE_REQUEST_FAILED,
           error);
-      this.onError_(shakaErr);
-      if (metadata && metadata.updatePromise) {
-        metadata.updatePromise.reject(shakaErr);
+      if (this.activeSessions_.size == 1) {
+        this.onError_(shakaErr);
+        if (metadata && metadata.updatePromise) {
+          metadata.updatePromise.reject(shakaErr);
+        }
+      } else {
+        if (metadata && metadata.updatePromise) {
+          metadata.updatePromise.reject(shakaErr);
+        }
+        this.activeSessions_.delete(session);
+        if (this.areAllSessionsLoaded_()) {
+          this.allSessionsLoaded_.resolve();
+          this.keyStatusTimer_.tickAfter(/* seconds= */ 0.1);
+        }
       }
       return;
     }

package/lib/media/media_source_engine.js

@@ -31,6 +31,7 @@ goog.require('shaka.util.Mp4BoxParsers');
 goog.require('shaka.util.Mp4Parser');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.PublicPromise');
+goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.TsParser');
 goog.require('shaka.lcevc.Dec');
 
@@ -237,18 +238,61 @@ shaka.media.MediaSourceEngine = class {
    * Checks if a certain type is supported.
    *
    * @param {shaka.extern.Stream} stream
-   * @return {boolean}
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @return {!Promise.<boolean>}
    */
-  static isStreamSupported(stream) {
+  static async isStreamSupported(stream, contentType) {
+    if (stream.createSegmentIndex) {
+      await stream.createSegmentIndex();
+    }
+    if (!stream.segmentIndex) {
+      return false;
+    }
+    if (stream.segmentIndex.isEmpty()) {
+      return true;
+    }
     const MimeUtils = shaka.util.MimeUtils;
-    const fullMimeType = MimeUtils.getFullType(stream.mimeType, stream.codecs);
-    const extendedMimeType = MimeUtils.getExtendedType(stream);
-    const fullMimeTypeWithAllCodecs = MimeUtils.getFullTypeWithAllCodecs(
-        stream.mimeType, stream.codecs);
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
-    return shaka.text.TextEngine.isTypeSupported(fullMimeType) ||
-        shaka.media.Capabilities.isTypeSupported(extendedMimeType) ||
-        TransmuxerEngine.isSupported(fullMimeTypeWithAllCodecs, stream.type);
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const StreamUtils = shaka.util.StreamUtils;
+    const seenCombos = new Set();
+    // Check each combination of mimeType and codecs within the segment index.
+    // Unfortunately we cannot use fullMimeTypes, as we ALSO need to check the
+    // getFullTypeWithAllCodecs (for the sake of the transmuxer) and we have no
+    // way of going from a full mimeType to a full mimeType with all codecs.
+    // As this function is only called in debug mode, a little inefficiency is
+    // acceptable.
+    for (const ref of stream.segmentIndex) {
+      const mimeType = ref.mimeType || stream.mimeType || '';
+      let codecs = ref.codecs || stream.codecs || '';
+      // Don't check the same combination of mimetype + codecs twice.
+      const combo = mimeType + ':' + codecs;
+      if (seenCombos.has(combo)) {
+        continue;
+      }
+      seenCombos.add(combo);
+      if (contentType == ContentType.TEXT) {
+        const fullMimeType = MimeUtils.getFullType(mimeType, codecs);
+        if (!shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
+          return false;
+        }
+      } else {
+        if (contentType == ContentType.VIDEO) {
+          codecs = StreamUtils.getCorrectVideoCodecs(codecs);
+        } else if (contentType == ContentType.AUDIO) {
+          codecs = StreamUtils.getCorrectAudioCodecs(codecs);
+        }
+        const extendedMimeType = MimeUtils.getExtendedType(
+            stream, mimeType, codecs);
+        const fullMimeType = MimeUtils.getFullTypeWithAllCodecs(
+            mimeType, codecs);
+        if (!shaka.media.Capabilities.isTypeSupported(extendedMimeType) &&
+            !TransmuxerEngine.isSupported(fullMimeType, stream.type)) {
+          return false;
+        }
+      }
+    }
+    return true;
   }
 
   /**
@@ -451,7 +495,8 @@ shaka.media.MediaSourceEngine = class {
 
     for (const contentType of streamsByType.keys()) {
       const stream = streamsByType.get(contentType);
-      this.initSourceBuffer_(contentType, stream, stream.codecs);
+      // eslint-disable-next-line no-await-in-loop
+      await this.initSourceBuffer_(contentType, stream, stream.codecs);
       if (this.needSplitMuxedContent_) {
         this.queues_[ContentType.AUDIO] = [];
         this.queues_[ContentType.VIDEO] = [];
@@ -467,13 +512,15 @@ shaka.media.MediaSourceEngine = class {
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
    * @param {string} codecs
+   * @return {!Promise}
    * @private
    */
-  initSourceBuffer_(contentType, stream, codecs) {
+  async initSourceBuffer_(contentType, stream, codecs) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     goog.asserts.assert(
-        shaka.media.MediaSourceEngine.isStreamSupported(stream),
+        await shaka.media.MediaSourceEngine.isStreamSupported(
+            stream, contentType),
         'Type negotiation should happen before MediaSourceEngine.init!');
 
     let mimeType = shaka.util.MimeUtils.getFullType(
@@ -490,7 +537,6 @@ shaka.media.MediaSourceEngine = class {
       const mimeTypeWithAllCodecs =
           shaka.util.MimeUtils.getFullTypeWithAllCodecs(
               stream.mimeType, codecs);
-      const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
       if (needTransmux) {
         const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
             ContentType.AUDIO, (codecs || '').split(','));
@@ -498,12 +544,12 @@ shaka.media.MediaSourceEngine = class {
             ContentType.VIDEO, (codecs || '').split(','));
         if (audioCodec && videoCodec) {
           this.needSplitMuxedContent_ = true;
-          this.initSourceBuffer_(ContentType.AUDIO, stream, audioCodec);
-          this.initSourceBuffer_(ContentType.VIDEO, stream, videoCodec);
+          await this.initSourceBuffer_(ContentType.AUDIO, stream, audioCodec);
+          await this.initSourceBuffer_(ContentType.VIDEO, stream, videoCodec);
           return;
         }
-        const transmuxerPlugin =
-            TransmuxerEngine.findTransmuxer(mimeTypeWithAllCodecs);
+        const transmuxerPlugin = shaka.transmuxer.TransmuxerEngine
+            .findTransmuxer(mimeTypeWithAllCodecs);
         if (transmuxerPlugin) {
           const transmuxer = transmuxerPlugin();
           this.transmuxers_[contentType] = transmuxer;
@@ -1793,16 +1839,22 @@ shaka.media.MediaSourceEngine = class {
 
       const totalOfBuffers = streamsByType.size;
       let numberOfSourceBufferAdded = 0;
-      this.eventManager_.listen(sourceBuffers, 'addsourcebuffer', (event) => {
+      const onSourceBufferAdded = () => {
         numberOfSourceBufferAdded++;
         if (numberOfSourceBufferAdded === totalOfBuffers) {
           sourceBufferAdded.resolve();
+          this.eventManager_.unlisten(sourceBuffers, 'addsourcebuffer',
+              onSourceBufferAdded);
         }
-      });
+      };
+
+      this.eventManager_.listen(sourceBuffers, 'addsourcebuffer',
+          onSourceBufferAdded);
 
       for (const contentType of streamsByType.keys()) {
         const stream = streamsByType.get(contentType);
-        this.initSourceBuffer_(contentType, stream, stream.codecs);
+        // eslint-disable-next-line no-await-in-loop
+        await this.initSourceBuffer_(contentType, stream, stream.codecs);
         if (this.needSplitMuxedContent_) {
           this.queues_[ContentType.AUDIO] = [];
           this.queues_[ContentType.VIDEO] = [];
@@ -1821,7 +1873,12 @@ shaka.media.MediaSourceEngine = class {
       this.destroyer_.ensureNotDestroyed();
 
       this.eventManager_.listenOnce(this.video_, 'canplaythrough', () => {
-        this.destroyer_.ensureNotDestroyed();
+        // Don't use ensureNotDestroyed() from this event listener, because
+        // that results in an uncaught exception.  Instead, just check the
+        // flag.
+        if (this.destroyer_.destroyed()) {
+          return;
+        }
 
         this.video_.autoplay = previousAutoPlayState;
         if (!previousPausedState) {
@@ -1935,10 +1992,12 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
+   * @param {string} refMimeType
+   * @param {string} refCodecs
    * @return {boolean}
    * @private
    */
-  isCodecSwitchNecessary_(contentType, stream) {
+  isCodecSwitchNecessary_(contentType, stream, refMimeType, refCodecs) {
     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
       return false;
     }
@@ -1948,8 +2007,7 @@ shaka.media.MediaSourceEngine = class {
     const currentBasicType = MimeUtils.getBasicType(
         this.sourceBufferTypes_[contentType]);
 
-    let newMimeType = shaka.util.MimeUtils.getFullType(
-        stream.mimeType, stream.codecs);
+    let newMimeType = shaka.util.MimeUtils.getFullType(refMimeType, refCodecs);
     let needTransmux = this.config_.forceTransmux;
     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
         (!this.sequenceMode_ &&
@@ -1958,7 +2016,7 @@ shaka.media.MediaSourceEngine = class {
     }
     const newMimeTypeWithAllCodecs =
         shaka.util.MimeUtils.getFullTypeWithAllCodecs(
-            stream.mimeType, stream.codecs);
+            refMimeType, refCodecs);
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     if (needTransmux) {
       const transmuxerPlugin =
@@ -1984,10 +2042,12 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
+   * @param {string} mimeType
+   * @param {string} codecs
    * @return {boolean}
    */
-  isResetMediaSourceNecessary(contentType, stream) {
-    if (!this.isCodecSwitchNecessary_(contentType, stream)) {
+  isResetMediaSourceNecessary(contentType, stream, mimeType, codecs) {
+    if (!this.isCodecSwitchNecessary_(contentType, stream, mimeType, codecs)) {
       return false;
     }