shaka-player 4.13.1 → 4.13.2

package/lib/media/media_source_engine.js

@@ -73,23 +73,21 @@ shaka.media.MediaSourceEngine = class {
     this.textDisplayer_ = textDisplayer;
 
     /**
-     * @private {!Object<shaka.util.ManifestParserUtils.ContentType,
-     *                    SourceBuffer>}
+     * @private {!Map<shaka.util.ManifestParserUtils.ContentType, SourceBuffer>}
      */
-    this.sourceBuffers_ = {};
+    this.sourceBuffers_ = new Map();
 
     /**
-     * @private {!Object<shaka.util.ManifestParserUtils.ContentType,
-     *                    string>}
+     * @private {!Map<shaka.util.ManifestParserUtils.ContentType, string>}
      */
-    this.sourceBufferTypes_ = {};
+    this.sourceBufferTypes_ = new Map();
 
 
     /**
-     * @private {!Object<shaka.util.ManifestParserUtils.ContentType,
+     * @private {!Map<shaka.util.ManifestParserUtils.ContentType,
      *                    boolean>}
      */
-    this.expectedEncryption_ = {};
+    this.expectedEncryption_ = new Map();
 
     /** @private {shaka.text.TextEngine} */
     this.textEngine_ = null;
@@ -101,16 +99,17 @@ shaka.media.MediaSourceEngine = class {
     this.lcevcDec_ = lcevcDec || null;
 
     /**
-     * @private {!Object<string,
-     *                    !Array<shaka.media.MediaSourceEngine.Operation>>}
+     * @private {!Map<string, !Array<shaka.media.MediaSourceEngine.Operation>>}
      */
-    this.queues_ = {};
+    this.queues_ = new Map();
 
     /** @private {shaka.util.EventManager} */
     this.eventManager_ = new shaka.util.EventManager();
 
-    /** @private {!Object<string, !shaka.extern.Transmuxer>} */
-    this.transmuxers_ = {};
+    /**
+     * @private {!Map<shaka.util.ManifestParserUtils.ContentType,
+                         !shaka.extern.Transmuxer>} */
+    this.transmuxers_ = new Map();
 
     /** @private {?shaka.media.IClosedCaptionParser} */
     this.captionParser_ = null;
@@ -171,10 +170,10 @@ shaka.media.MediaSourceEngine = class {
     this.lastDuration_ = null;
 
     /**
-     * @private {!Object<shaka.util.ManifestParserUtils.ContentType,
+     * @private {!Map<shaka.util.ManifestParserUtils.ContentType,
      *                    !shaka.util.TsParser>}
      */
-    this.tsParsers_ = {};
+    this.tsParsers_ = new Map();
 
     /** @private {?number} */
     this.firstVideoTimestamp_ = null;
@@ -456,13 +455,14 @@ shaka.media.MediaSourceEngine = class {
 
     const cleanup = [];
 
-    for (const contentType in this.queues_) {
+    for (const [key, q] of this.queues_) {
       // Make a local copy of the queue and the first item.
-      const q = this.queues_[contentType];
       const inProgress = q[0];
 
+      const contentType = /** @type {string} */(key);
+
       // Drop everything else out of the original queue.
-      this.queues_[contentType] = q.slice(0, 1);
+      this.queues_.set(contentType, q.slice(0, 1));
 
       // We will wait for this item to complete/fail.
       if (inProgress) {
@@ -481,8 +481,8 @@ shaka.media.MediaSourceEngine = class {
 
     await Promise.all(cleanup);
 
-    for (const contentType in this.transmuxers_) {
-      this.transmuxers_[contentType].destroy();
+    for (const transmuxer of this.transmuxers_.values()) {
+      transmuxer.destroy();
     }
 
     if (this.eventManager_) {
@@ -507,22 +507,23 @@ shaka.media.MediaSourceEngine = class {
     this.mediaSource_ = null;
     this.textEngine_ = null;
     this.textDisplayer_ = null;
-    this.sourceBuffers_ = {};
-    this.transmuxers_ = {};
+    this.sourceBuffers_.clear();
+    this.expectedEncryption_.clear();
+    this.transmuxers_.clear();
     this.captionParser_ = null;
     if (goog.DEBUG) {
-      for (const contentType in this.queues_) {
+      for (const [contentType, q] of this.queues_) {
         goog.asserts.assert(
-            this.queues_[contentType].length == 0,
+            q.length == 0,
             contentType + ' queue should be empty after destroy!');
       }
     }
-    this.queues_ = {};
+    this.queues_.clear();
 
     // This object is owned by Player
     this.lcevcDec_ = null;
 
-    this.tsParsers_ = {};
+    this.tsParsers_.clear();
     this.playerInterface_ = null;
   }
 
@@ -581,7 +582,7 @@ shaka.media.MediaSourceEngine = class {
         this.manifestType_ == shaka.media.ManifestParser.HLS &&
         !this.ignoreManifestTimestampsInSegmentsMode_;
 
-    this.tsParsers_ = {};
+    this.tsParsers_.clear();
     this.firstVideoTimestamp_ = null;
     this.firstVideoReferenceStartTime_ = null;
     this.firstAudioTimestamp_ = null;
@@ -593,10 +594,10 @@ shaka.media.MediaSourceEngine = class {
       // 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] = [];
+        this.queues_.set(ContentType.AUDIO, []);
+        this.queues_.set(ContentType.VIDEO, []);
       } else {
-        this.queues_[contentType] = [];
+        this.queues_.set(contentType, []);
       }
     }
     const audio = streamsByType.get(ContentType.AUDIO);
@@ -656,7 +657,7 @@ shaka.media.MediaSourceEngine = class {
             .findTransmuxer(mimeTypeWithAllCodecs);
         if (transmuxerPlugin) {
           const transmuxer = transmuxerPlugin();
-          this.transmuxers_[contentType] = transmuxer;
+          this.transmuxers_.set(contentType, transmuxer);
           mimeType =
               transmuxer.convertCodecs(contentType, mimeTypeWithAllCodecs);
         }
@@ -691,9 +692,9 @@ shaka.media.MediaSourceEngine = class {
       this.eventManager_.listen(
           sourceBuffer, 'updateend',
           () => this.onUpdateEnd_(contentType));
-      this.sourceBuffers_[contentType] = sourceBuffer;
-      this.sourceBufferTypes_[contentType] = mimeType;
-      this.expectedEncryption_[contentType] = !!stream.drmInfos.length;
+      this.sourceBuffers_.set(contentType, sourceBuffer);
+      this.sourceBufferTypes_.set(contentType, mimeType);
+      this.expectedEncryption_.set(contentType, !!stream.drmInfos.length);
     }
   }
 
@@ -767,7 +768,7 @@ shaka.media.MediaSourceEngine = class {
    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
    */
   bufferStart(contentType) {
-    if (!Object.keys(this.sourceBuffers_).length) {
+    if (!this.sourceBuffers_.size) {
       return null;
     }
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
@@ -785,7 +786,7 @@ shaka.media.MediaSourceEngine = class {
    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
    */
   bufferEnd(contentType) {
-    if (!Object.keys(this.sourceBuffers_).length) {
+    if (!this.sourceBuffers_.size) {
       return null;
     }
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
@@ -872,9 +873,9 @@ shaka.media.MediaSourceEngine = class {
       return null;
     }
     try {
-      return this.sourceBuffers_[contentType].buffered;
+      return this.sourceBuffers_.get(contentType).buffered;
     } catch (exception) {
-      if (contentType in this.sourceBuffers_) {
+      if (this.sourceBuffers_.has(contentType)) {
         // Note: previous MediaSource errors may cause access to |buffered| to
         // throw.
         shaka.log.error('failed to get buffered range for ' + contentType,
@@ -973,12 +974,12 @@ shaka.media.MediaSourceEngine = class {
       }
     } else if (!mimeType.includes('/mp4') && !mimeType.includes('/webm') &&
         shaka.util.TsParser.probe(uint8ArrayData)) {
-      if (!this.tsParsers_[contentType]) {
-        this.tsParsers_[contentType] = new shaka.util.TsParser();
+      if (!this.tsParsers_.has(contentType)) {
+        this.tsParsers_.set(contentType, new shaka.util.TsParser());
       } else {
-        this.tsParsers_[contentType].clearData();
+        this.tsParsers_.get(contentType).clearData();
       }
-      const tsParser = this.tsParsers_[contentType].parse(uint8ArrayData);
+      const tsParser = this.tsParsers_.get(contentType).parse(uint8ArrayData);
       const startTime = tsParser.getStartTime(contentType);
       if (startTime != null) {
         timestamp = startTime;
@@ -1203,16 +1204,16 @@ shaka.media.MediaSourceEngine = class {
       return;
     }
 
-    if (!this.sourceBuffers_[contentType]) {
+    if (!this.sourceBuffers_.has(contentType)) {
       shaka.log.warning('Attempted to restore a non-existent source buffer');
       return;
     }
 
-    let timestampOffset = this.sourceBuffers_[contentType].timestampOffset;
+    let timestampOffset = this.sourceBuffers_.get(contentType).timestampOffset;
 
-    let mimeType = this.sourceBufferTypes_[contentType];
-    if (this.transmuxers_[contentType]) {
-      mimeType = this.transmuxers_[contentType].getOriginalMimeType();
+    let mimeType = this.sourceBufferTypes_.get(contentType);
+    if (this.transmuxers_.has(contentType)) {
+      mimeType = this.transmuxers_.get(contentType).getOriginalMimeType();
     }
     if (reference) {
       const {timestamp, metadata} = this.getTimestampAndDispatchMetadata(
@@ -1256,7 +1257,7 @@ shaka.media.MediaSourceEngine = class {
         // adjust TimestampOffset relative to 0 because segments do not have
         // any timestamp information.
         if (!this.sequenceMode_ &&
-            RAW_FORMATS.includes(this.sourceBufferTypes_[contentType])) {
+            RAW_FORMATS.includes(this.sourceBufferTypes_.get(contentType))) {
           realTimestamp = 0;
         }
         const calculatedTimestampOffset = reference.startTime - realTimestamp;
@@ -1282,7 +1283,7 @@ shaka.media.MediaSourceEngine = class {
         // Prefer video for this when available.
         const isBestSourceBufferForTimestamps =
             contentType == ContentType.VIDEO ||
-            !(ContentType.VIDEO in this.sourceBuffers_);
+            !(this.sourceBuffers_.has(ContentType.VIDEO));
         if (isBestSourceBufferForTimestamps) {
           this.textSequenceModeOffset_.resolve(timestampOffset);
         }
@@ -1317,8 +1318,8 @@ shaka.media.MediaSourceEngine = class {
       }
     }
 
-    if (this.transmuxers_[contentType]) {
-      data = await this.transmuxers_[contentType].transmux(
+    if (this.transmuxers_.has(contentType)) {
+      data = await this.transmuxers_.get(contentType).transmux(
           data, stream, reference, this.mediaSource_.duration, contentType);
     }
 
@@ -1337,7 +1338,7 @@ shaka.media.MediaSourceEngine = class {
         if (this.manifestType_ == shaka.media.ManifestParser.HLS &&
             !this.needSplitMuxedContent_ &&
             contentType == ContentType.AUDIO &&
-            this.sourceBuffers_[ContentType.VIDEO]) {
+            this.sourceBuffers_.has(ContentType.VIDEO)) {
           const compensation = await this.audioCompensation_;
           // Only apply compensation if the difference is greater than 100ms
           if (Math.abs(compensation) > 0.1) {
@@ -1692,13 +1693,13 @@ shaka.media.MediaSourceEngine = class {
       // have to insert a dummy operation into the beginning of each queue,
       // which the 'updateend' handler will remove.
       if (duration < this.mediaSource_.duration) {
-        for (const contentType in this.sourceBuffers_) {
+        for (const contentType of this.sourceBuffers_.keys()) {
           const dummyOperation = {
             start: () => {},
             p: new shaka.util.PublicPromise(),
             uri: null,
           };
-          this.queues_[contentType].unshift(dummyOperation);
+          this.queues_.get(contentType).unshift(dummyOperation);
         }
       }
 
@@ -1771,7 +1772,7 @@ shaka.media.MediaSourceEngine = class {
     }
 
     // This will trigger an 'updateend' event.
-    this.sourceBuffers_[contentType].appendBuffer(data);
+    this.sourceBuffers_.get(contentType).appendBuffer(data);
   }
 
   /**
@@ -1790,7 +1791,7 @@ shaka.media.MediaSourceEngine = class {
     }
 
     // This will trigger an 'updateend' event.
-    this.sourceBuffers_[contentType].remove(startTime, endTime);
+    this.sourceBuffers_.get(contentType).remove(startTime, endTime);
   }
 
   /**
@@ -1801,18 +1802,18 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   abort_(contentType) {
+    const sourceBuffer = this.sourceBuffers_.get(contentType);
     // Save the append window, which is reset on abort().
-    const appendWindowStart =
-        this.sourceBuffers_[contentType].appendWindowStart;
-    const appendWindowEnd = this.sourceBuffers_[contentType].appendWindowEnd;
+    const appendWindowStart = sourceBuffer.appendWindowStart;
+    const appendWindowEnd = sourceBuffer.appendWindowEnd;
 
     // This will not trigger an 'updateend' event, since nothing is happening.
     // This is only to reset MSE internals, not to abort an actual operation.
-    this.sourceBuffers_[contentType].abort();
+    sourceBuffer.abort();
 
     // Restore the append window.
-    this.sourceBuffers_[contentType].appendWindowStart = appendWindowStart;
-    this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
+    sourceBuffer.appendWindowStart = appendWindowStart;
+    sourceBuffer.appendWindowEnd = appendWindowEnd;
 
     // Fake an 'updateend' event to resolve the operation.
     this.onUpdateEnd_(contentType);
@@ -1854,7 +1855,7 @@ shaka.media.MediaSourceEngine = class {
       timestampOffset += 0.001;
     }
 
-    this.sourceBuffers_[contentType].timestampOffset = timestampOffset;
+    this.sourceBuffers_.get(contentType).timestampOffset = timestampOffset;
 
     // Fake an 'updateend' event to resolve the operation.
     this.onUpdateEnd_(contentType);
@@ -1868,12 +1869,13 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   setAppendWindow_(contentType, appendWindowStart, appendWindowEnd) {
+    const sourceBuffer = this.sourceBuffers_.get(contentType);
     // You can't set start > end, so first set start to 0, then set the new
     // end, then set the new start.  That way, there are no intermediate
     // states which are invalid.
-    this.sourceBuffers_[contentType].appendWindowStart = 0;
-    this.sourceBuffers_[contentType].appendWindowEnd = appendWindowEnd;
-    this.sourceBuffers_[contentType].appendWindowStart = appendWindowStart;
+    sourceBuffer.appendWindowStart = 0;
+    sourceBuffer.appendWindowEnd = appendWindowEnd;
+    sourceBuffer.appendWindowStart = appendWindowStart;
 
     // Fake an 'updateend' event to resolve the operation.
     this.onUpdateEnd_(contentType);
@@ -1884,9 +1886,9 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   onError_(contentType) {
-    const operation = this.queues_[contentType][0];
+    const operation = this.queues_.get(contentType)[0];
     goog.asserts.assert(operation, 'Spurious error event!');
-    goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
+    goog.asserts.assert(!this.sourceBuffers_.get(contentType).updating,
         'SourceBuffer should not be updating on error!');
     const code = this.video_.error ? this.video_.error.code : 0;
     operation.p.reject(new shaka.util.Error(
@@ -1909,12 +1911,12 @@ shaka.media.MediaSourceEngine = class {
     if (this.reloadingMediaSource_) {
       return;
     }
-    const operation = this.queues_[contentType][0];
+    const operation = this.queues_.get(contentType)[0];
     goog.asserts.assert(operation, 'Spurious updateend event!');
     if (!operation) {
       return;
     }
-    goog.asserts.assert(!this.sourceBuffers_[contentType].updating,
+    goog.asserts.assert(!this.sourceBuffers_.get(contentType).updating,
         'SourceBuffer should not be updating on updateend!');
     operation.p.resolve();
     this.popFromQueue_(contentType);
@@ -1936,9 +1938,9 @@ shaka.media.MediaSourceEngine = class {
       p: new shaka.util.PublicPromise(),
       uri,
     };
-    this.queues_[contentType].push(operation);
+    this.queues_.get(contentType).push(operation);
 
-    if (this.queues_[contentType].length == 1) {
+    if (this.queues_.get(contentType).length == 1) {
       this.startOperation_(contentType);
     }
     return operation.p;
@@ -1958,7 +1960,7 @@ shaka.media.MediaSourceEngine = class {
     /** @type {!Array<!shaka.util.PublicPromise>} */
     const allWaiters = [];
     /** @type {!Array<!shaka.util.ManifestParserUtils.ContentType>} */
-    const contentTypes = Object.keys(this.sourceBuffers_);
+    const contentTypes = Array.from(this.sourceBuffers_.keys());
 
     // Enqueue a 'wait' operation onto each queue.
     // This operation signals its readiness when it starts.
@@ -1971,10 +1973,12 @@ shaka.media.MediaSourceEngine = class {
         uri: null,
       };
 
-      this.queues_[contentType].push(operation);
+      const queue = this.queues_.get(contentType);
+
+      queue.push(operation);
       allWaiters.push(ready);
 
-      if (this.queues_[contentType].length == 1) {
+      if (queue.length == 1) {
         operation.start();
       }
     }
@@ -1994,14 +1998,13 @@ shaka.media.MediaSourceEngine = class {
       // are wiped in destroy.
       if (goog.DEBUG) {
         for (const contentType of contentTypes) {
-          if (this.queues_[contentType].length) {
-            goog.asserts.assert(
-                this.queues_[contentType].length == 1,
+          const queue = this.queues_.get(contentType);
+          if (queue.length) {
+            goog.asserts.assert(queue.length == 1,
                 'Should be at most one item in queue!');
-            goog.asserts.assert(
-                allWaiters.includes(this.queues_[contentType][0].p),
+            goog.asserts.assert(allWaiters.includes(queue[0].p),
                 'The item in queue should be one of our waiters!');
-            this.queues_[contentType].shift();
+            queue.shift();
           }
         }
       }
@@ -2012,7 +2015,7 @@ shaka.media.MediaSourceEngine = class {
       // If we did it correctly, nothing is updating.
       for (const contentType of contentTypes) {
         goog.asserts.assert(
-            this.sourceBuffers_[contentType].updating == false,
+            this.sourceBuffers_.get(contentType).updating == false,
             'SourceBuffers should not be updating after a blocking op!');
       }
     }
@@ -2042,9 +2045,9 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   popFromQueue_(contentType) {
-    goog.asserts.assert(this.queues_[contentType], 'Queue should exist');
+    goog.asserts.assert(this.queues_.has(contentType), 'Queue should exist');
     // Remove the in-progress operation, which is now complete.
-    this.queues_[contentType].shift();
+    this.queues_.get(contentType).shift();
     this.startOperation_(contentType);
   }
 
@@ -2055,7 +2058,7 @@ shaka.media.MediaSourceEngine = class {
    */
   startOperation_(contentType) {
     // Retrieve the next operation, if any, from the queue and start it.
-    const next = this.queues_[contentType][0];
+    const next = this.queues_.get(contentType)[0];
     if (next) {
       try {
         next.start();
@@ -2123,7 +2126,7 @@ shaka.media.MediaSourceEngine = class {
     const Platform = shaka.util.Platform;
 
     const isInitSegment = startTime == null;
-    const encryptionExpected = this.expectedEncryption_[contentType];
+    const encryptionExpected = this.expectedEncryption_.get(contentType);
     const keySystem = this.playerInterface_.getKeySystem();
 
     // If:
@@ -2141,7 +2144,7 @@ shaka.media.MediaSourceEngine = class {
         encryptionExpected &&
         Platform.requiresEncryptionInfoInAllInitSegments(keySystem) &&
         shaka.util.MimeUtils.getContainerType(
-            this.sourceBufferTypes_[contentType]) == 'mp4') {
+            this.sourceBufferTypes_.get(contentType)) == 'mp4') {
       shaka.log.debug('Forcing fake encryption information in init segment.');
       segment = shaka.media.ContentWorkarounds.fakeEncryption(segment, uri);
     }
@@ -2149,7 +2152,7 @@ shaka.media.MediaSourceEngine = class {
     if (isInitSegment &&
         Platform.requiresEC3InitSegments() &&
         shaka.util.MimeUtils.getContainerType(
-            this.sourceBufferTypes_[contentType]) == 'mp4') {
+            this.sourceBufferTypes_.get(contentType)) == 'mp4') {
       shaka.log.debug('Forcing fake EC-3 information in init segment.');
       segment = shaka.media.ContentWorkarounds.fakeEC3(segment);
     }
@@ -2171,19 +2174,20 @@ shaka.media.MediaSourceEngine = class {
       shaka.log.debug(`Change not supported for ${contentType}`);
       return;
     }
+    const sourceBuffer = this.sourceBufferTypes_.get(contentType);
     shaka.log.debug(
-        `Change Type: ${this.sourceBufferTypes_[contentType]} -> ${mimeType}`);
+        `Change Type: ${sourceBuffer} -> ${mimeType}`);
     if (shaka.media.Capabilities.isChangeTypeSupported()) {
-      if (this.transmuxers_[contentType]) {
-        this.transmuxers_[contentType].destroy();
-        delete this.transmuxers_[contentType];
+      if (this.transmuxers_.has(contentType)) {
+        this.transmuxers_.get(contentType).destroy();
+        this.transmuxers_.delete(contentType);
       }
       if (transmuxer) {
-        this.transmuxers_[contentType] = transmuxer;
+        this.transmuxers_.set(contentType, transmuxer);
       }
       const type = this.addExtraFeaturesToMimeType_(mimeType);
-      this.sourceBuffers_[contentType].changeType(type);
-      this.sourceBufferTypes_[contentType] = mimeType;
+      this.sourceBuffers_.get(contentType).changeType(type);
+      this.sourceBufferTypes_.set(contentType, mimeType);
     } else {
       shaka.log.debug('Change Type not supported');
     }
@@ -2237,19 +2241,18 @@ shaka.media.MediaSourceEngine = class {
     try {
       this.eventManager_.removeAll();
 
-      for (const contentType in this.transmuxers_) {
-        this.transmuxers_[contentType].destroy();
+      for (const transmuxer of this.transmuxers_.values()) {
+        transmuxer.destroy();
       }
-      for (const contentType in this.sourceBuffers_) {
-        const sourceBuffer = this.sourceBuffers_[contentType];
+      for (const sourceBuffer of this.sourceBuffers_.values()) {
         try {
           this.mediaSource_.removeSourceBuffer(sourceBuffer);
         } catch (e) {
           shaka.log.debug('Exception on removeSourceBuffer', e);
         }
       }
-      this.transmuxers_ = {};
-      this.sourceBuffers_ = {};
+      this.transmuxers_.clear();
+      this.sourceBuffers_.clear();
 
       const previousDuration = this.mediaSource_.duration;
       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
@@ -2288,8 +2291,8 @@ shaka.media.MediaSourceEngine = class {
       if (audio && audio.isAudioMuxedInVideo) {
         this.needSplitMuxedContent_ = true;
       }
-      if (this.needSplitMuxedContent_ && !this.queues_[ContentType.AUDIO]) {
-        this.queues_[ContentType.AUDIO] = [];
+      if (this.needSplitMuxedContent_ && !this.queues_.has(ContentType.AUDIO)) {
+        this.queues_.set(ContentType.AUDIO, []);
       }
 
       // Fake a seek to catchup the playhead.
@@ -2408,9 +2411,9 @@ shaka.media.MediaSourceEngine = class {
     }
     const MimeUtils = shaka.util.MimeUtils;
     const currentCodec = MimeUtils.getNormalizedCodec(
-        MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
+        MimeUtils.getCodecs(this.sourceBufferTypes_.get(contentType)));
     const currentBasicType = MimeUtils.getBasicType(
-        this.sourceBufferTypes_[contentType]);
+        this.sourceBufferTypes_.get(contentType));
 
     const realInfo = this.getRealInfo_(contentType, mimeType, codecs);
     const transmuxer = realInfo.transmuxer;
@@ -2424,9 +2427,9 @@ shaka.media.MediaSourceEngine = class {
       const muxedRealInfo =
           this.getRealInfo_(ContentType.AUDIO, mimeType, codecs);
       const muxedCurrentCodec = MimeUtils.getNormalizedCodec(
-          MimeUtils.getCodecs(this.sourceBufferTypes_[ContentType.AUDIO]));
+          MimeUtils.getCodecs(this.sourceBufferTypes_.get(ContentType.AUDIO)));
       const muxedCurrentBasicType = MimeUtils.getBasicType(
-          this.sourceBufferTypes_[ContentType.AUDIO]);
+          this.sourceBufferTypes_.get(ContentType.AUDIO));
       muxedContentCheck = muxedCurrentCodec == muxedRealInfo.codec &&
         muxedCurrentBasicType == muxedRealInfo.basicType;
       if (muxedRealInfo.transmuxer) {
@@ -2437,18 +2440,19 @@ shaka.media.MediaSourceEngine = class {
     // Current/new codecs base and basic type match then no need to switch
     if (currentCodec === newCodec && currentBasicType === newBasicType &&
         muxedContentCheck) {
-      if (this.transmuxers_[contentType] && !transmuxer) {
-        this.transmuxers_[contentType].destroy();
-        delete this.transmuxers_[contentType];
-      } else if (!this.transmuxers_[contentType] && transmuxer) {
-        this.transmuxers_[contentType] = transmuxer;
+      if (this.transmuxers_.has(contentType) && !transmuxer) {
+        this.transmuxers_.get(contentType).destroy();
+        this.transmuxers_.delete(contentType);
+      } else if (!this.transmuxers_.has(contentType) && transmuxer) {
+        this.transmuxers_.set(contentType, transmuxer);
       } else if (transmuxer) {
         // Compare if the transmuxer is different
-        if (this.transmuxers_[contentType] &&
-            this.transmuxers_[contentType].transmux != transmuxer.transmux) {
-          this.transmuxers_[contentType].destroy();
-          delete this.transmuxers_[contentType];
-          this.transmuxers_[contentType] = transmuxer;
+        if (this.transmuxers_.has(contentType) &&
+            this.transmuxers_.get(contentType).transmux !=
+              transmuxer.transmux) {
+          this.transmuxers_.get(contentType).destroy();
+          this.transmuxers_.delete(contentType);
+          this.transmuxers_.set(contentType, transmuxer);
         } else {
           transmuxer.destroy();
         }
@@ -2458,7 +2462,7 @@ shaka.media.MediaSourceEngine = class {
 
     let allowChangeType = true;
     if (this.needSplitMuxedContent_ || (transmuxerMuxed &&
-        transmuxer && !this.transmuxers_[contentType])) {
+        transmuxer && !this.transmuxers_.has(contentType))) {
       allowChangeType = false;
     }
 
@@ -2490,9 +2494,9 @@ shaka.media.MediaSourceEngine = class {
     }
     const MimeUtils = shaka.util.MimeUtils;
     const currentCodec = MimeUtils.getNormalizedCodec(
-        MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
+        MimeUtils.getCodecs(this.sourceBufferTypes_.get(contentType)));
     const currentBasicType = MimeUtils.getBasicType(
-        this.sourceBufferTypes_[contentType]);
+        this.sourceBufferTypes_.get(contentType));
 
     let newMimeType = shaka.util.MimeUtils.getFullType(refMimeType, refCodecs);
     let needTransmux = this.config_.forceTransmux;