shaka-player 3.1.2 → 3.1.6

package/lib/cast/cast_proxy.js

@@ -120,6 +120,9 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
     this.videoProxy_ = null;
     this.playerProxy_ = null;
 
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     return Promise.all(waitFor);
   }
 
@@ -525,7 +528,8 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
       goog.asserts.assert(error instanceof shaka.util.Error,
           'Wrong error type!');
       const eventType = shaka.Player.EventName.Error;
-      const event = new shaka.util.FakeEvent(eventType, {'detail': error});
+      const data = (new Map()).set('detail', error);
+      const event = new shaka.util.FakeEvent(eventType, data);
       this.localPlayer_.dispatchEvent(event);
     });
   }
@@ -598,7 +602,7 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
 
     // Convert this real Event into a FakeEvent for dispatch from our
     // FakeEventListener.
-    const fakeEvent = new shaka.util.FakeEvent(event.type, event);
+    const fakeEvent = shaka.util.FakeEvent.fromRealEvent(event);
     this.videoEventTarget_.dispatchEvent(fakeEvent);
   }
 

package/lib/cast/cast_receiver.js

@@ -238,6 +238,9 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
     this.shakaBus_ = null;
     this.genericBus_ = null;
 
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     await Promise.all(waitFor);
 
     const manager = cast.receiver.CastReceiverManager.getInstance();
@@ -407,7 +410,8 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
         goog.asserts.assert(error instanceof shaka.util.Error,
             'Wrong error type!');
         const eventType = shaka.Player.EventName.Error;
-        const event = new shaka.util.FakeEvent(eventType, {'detail': error});
+        const data = (new Map()).set('detail', error);
+        const event = new shaka.util.FakeEvent(eventType, data);
         // Only dispatch the event if the player still exists.
         if (this.player_) {
           this.player_.dispatchEvent(event);

package/lib/cast/cast_sender.js

@@ -647,7 +647,7 @@ shaka.cast.CastSender = class {
       case 'event': {
         const targetName = message['targetName'];
         const event = message['event'];
-        const fakeEvent = new shaka.util.FakeEvent(event['type'], event);
+        const fakeEvent = shaka.util.FakeEvent.fromRealEvent(event);
         this.onRemoteEvent_(targetName, fakeEvent);
         break;
       }
@@ -725,7 +725,7 @@ shaka.cast.CastSender = class {
 
       // Dispatch it through the Player proxy
       const fakeEvent = new shaka.util.FakeEvent(
-          'error', {'detail': shakaError});
+          'error', (new Map()).set('detail', shakaError));
       this.onRemoteEvent_('player', fakeEvent);
 
       // Force this session to disconnect and transfer playback to the local

package/lib/cea/sei_processor.js

@@ -17,31 +17,31 @@ shaka.cea.SeiProcessor = class {
    * @return {!Iterable.<!Uint8Array>}
    */
   * process(naluData) {
-    const emuCount = this.removeEmu_(naluData);
+    const naluClone = this.removeEmu(naluData);
 
     // The following is an implementation of section 7.3.2.3.1
     // in Rec. ITU-T H.264 (06/2019), the H.264 spec.
     let offset = 0;
 
-    while (offset + emuCount < naluData.length) {
+    while (offset < naluClone.length) {
       let payloadType = 0; // SEI payload type as defined by H.264 spec
-      while (naluData[offset] == 0xFF) {
+      while (naluClone[offset] == 0xFF) {
         payloadType += 255;
         offset++;
       }
-      payloadType += naluData[offset++];
+      payloadType += naluClone[offset++];
 
       let payloadSize = 0; // SEI payload size as defined by H.264 spec
-      while (naluData[offset] == 0xFF) {
+      while (naluClone[offset] == 0xFF) {
         payloadSize += 255;
         offset++;
       }
-      payloadSize += naluData[offset++];
+      payloadSize += naluClone[offset++];
 
       // Payload type 4 is user_data_registered_itu_t_t35, as per the H.264
       // spec. This payload type contains caption data.
       if (payloadType == 0x04) {
-        yield naluData.subarray(offset, offset + payloadSize);
+        yield naluClone.subarray(offset, offset + payloadSize);
       }
       offset += payloadSize;
     }
@@ -50,28 +50,35 @@ shaka.cea.SeiProcessor = class {
 
   /**
    * Removes H.264 emulation prevention bytes from the byte array.
+   *
+   * Note: Remove bytes by shifting will cause Chromium (VDA) to complain
+   * about conformance. Recreating a new array solves it.
+   *
    * @param {!Uint8Array} naluData NALU from which EMUs should be removed.
-   * @return {number} The number of removed emulation prevention bytes.
-   * @private
+   * @return {!Uint8Array} The NALU with the emulation prevention byte removed.
    */
-  removeEmu_(naluData) {
+  removeEmu(naluData) {
+    let naluClone = naluData;
     let zeroCount = 0;
     let src = 0;
-    let dst = 0;
-    while (src < naluData.length) {
-      if (zeroCount == 2 && naluData[src] == 0x03) {
+    while (src < naluClone.length) {
+      if (zeroCount == 2 && naluClone[src] == 0x03) {
+        // 0x00, 0x00, 0x03 pattern detected
         zeroCount = 0;
+
+        // Splice the array and recreate a new one, instead of shifting bytes
+        const newArr = [...naluClone];
+        newArr.splice(src, 1);
+        naluClone = new Uint8Array(newArr);
       } else {
-        if (naluData[src] == 0x00) {
+        if (naluClone[src] == 0x00) {
           zeroCount++;
         } else {
           zeroCount = 0;
         }
-        naluData[dst] = naluData[src];
-        dst++;
       }
       src++;
     }
-    return (src - dst);
+    return naluClone;
   }
 };

package/lib/dash/dash_parser.js

@@ -95,6 +95,18 @@ shaka.dash.DashParser = class {
     /** @private {!shaka.util.OperationManager} */
     this.operationManager_ = new shaka.util.OperationManager();
 
+    /**
+     * Largest period start time seen.
+     * @private {?number}
+     */
+    this.largestPeriodStartTime_ = null;
+
+    /**
+     * Period IDs seen in previous manifest.
+     * @private {!Array.<number>}
+     */
+    this.lastManifestUpdatePeriodIds_ = [];
+
     /**
      * The minimum of the availabilityTimeOffset values among the adaptation
      * sets.
@@ -384,6 +396,24 @@ shaka.dash.DashParser = class {
           this.config_.dash.autoCorrectDrift);
     }
 
+    presentationTimeline.setStatic(mpdType == 'static');
+
+    const isLive = presentationTimeline.isLive();
+
+    // If it's live, we check for an override.
+    if (isLive && !isNaN(this.config_.availabilityWindowOverride)) {
+      segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
+    }
+
+    // If it's null, that means segments are always available.  This is always
+    // the case for VOD, and sometimes the case for live.
+    if (segmentAvailabilityDuration == null) {
+      segmentAvailabilityDuration = Infinity;
+    }
+
+    presentationTimeline.setSegmentAvailabilityDuration(
+        segmentAvailabilityDuration);
+
     const profiles = mpd.getAttribute('profiles') || '';
 
     /** @type {shaka.dash.DashParser.Context} */
@@ -406,7 +436,6 @@ shaka.dash.DashParser = class {
     const duration = periodsAndDuration.duration;
     const periods = periodsAndDuration.periods;
 
-    presentationTimeline.setStatic(mpdType == 'static');
     if (mpdType == 'static' ||
         !periodsAndDuration.durationDerivedFromPeriods) {
       // Ignore duration calculated from Period lengths if this is dynamic.
@@ -425,6 +454,7 @@ shaka.dash.DashParser = class {
         this.lowLatencyMode_ = this.playerInterface_.isLowLatencyMode();
       }
     }
+
     if (this.lowLatencyMode_) {
       presentationTimeline.setAvailabilityTimeOffset(
           this.minTotalAvailabilityTimeOffset_);
@@ -438,22 +468,6 @@ shaka.dash.DashParser = class {
         'https://bit.ly/3clctcj for details.');
     }
 
-    const isLive = presentationTimeline.isLive();
-
-    // If it's live, we check for an override.
-    if (isLive && !isNaN(this.config_.availabilityWindowOverride)) {
-      segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
-    }
-
-    // If it's null, that means segments are always available.  This is always
-    // the case for VOD, and sometimes the case for live.
-    if (segmentAvailabilityDuration == null) {
-      segmentAvailabilityDuration = Infinity;
-    }
-
-    presentationTimeline.setSegmentAvailabilityDuration(
-        segmentAvailabilityDuration);
-
     // Use @maxSegmentDuration to override smaller, derived values.
     presentationTimeline.notifyMaxSegmentDuration(maxSegmentDuration || 1);
     if (goog.DEBUG) {
@@ -533,6 +547,7 @@ shaka.dash.DashParser = class {
     for (const {i, item: elem, next} of enumerate(periodNodes)) {
       const start = /** @type {number} */ (
         XmlUtils.parseAttr(elem, 'start', XmlUtils.parseDuration, prevEnd));
+      const periodId = elem.id;
       const givenDuration =
           XmlUtils.parseAttr(elem, 'duration', XmlUtils.parseDuration);
 
@@ -566,6 +581,42 @@ shaka.dash.DashParser = class {
         periodDuration = givenDuration;
       }
 
+      /**
+       * This is to improve robustness when the player observes manifest with
+       * past periods that are inconsistent to previous ones.
+       *
+       * This may happen when a CDN or proxy server switches its upstream from
+       * one encoder to another redundant encoder.
+       *
+       * Skip periods that match all of the following criteria:
+       * - Start time is earlier than latest period start time ever seen
+       * - Period ID is never seen in the previous manifest
+       * - Not the last period in the manifest
+       *
+       * Periods that meet the aforementioned criteria are considered invalid
+       * and should be safe to discard.
+       */
+
+      if (this.largestPeriodStartTime_ !== null &&
+        periodId !== null && start !== null &&
+        start < this.largestPeriodStartTime_ &&
+        !this.lastManifestUpdatePeriodIds_.includes(periodId) &&
+        i + 1 != periodNodes.length) {
+        shaka.log.debug(
+            `Skipping Period with ID ${periodId} as its start time is smaller` +
+            ' than the largest period start time that has been seen, and ID ' +
+            'is unseen before');
+        continue;
+      }
+
+
+      // Save maximum period start time if it is the last period
+      if (start !== null &&
+        (this.largestPeriodStartTime_ === null ||
+          start > this.largestPeriodStartTime_)) {
+        this.largestPeriodStartTime_ = start;
+      }
+
       // Parse child nodes.
       const info = {
         start: start,
@@ -597,6 +648,9 @@ shaka.dash.DashParser = class {
       prevEnd = start + periodDuration;
     } // end of period parsing loop
 
+    // Replace previous seen periods with the current one.
+    this.lastManifestUpdatePeriodIds_ = periods.map((el) => el.id);
+
     if (presentationDuration != null) {
       if (prevEnd != presentationDuration) {
         shaka.log.warning(
@@ -648,8 +702,12 @@ shaka.dash.DashParser = class {
 
     const eventStreamNodes =
         XmlUtils.findChildren(periodInfo.node, 'EventStream');
+    const availabilityStart =
+        context.presentationTimeline.getSegmentAvailabilityStart();
+
     for (const node of eventStreamNodes) {
-      this.parseEventStream_(periodInfo.start, periodInfo.duration, node);
+      this.parseEventStream_(
+          periodInfo.start, periodInfo.duration, node, availabilityStart);
     }
 
     const adaptationSetNodes =
@@ -808,6 +866,25 @@ shaka.dash.DashParser = class {
       }
     }
 
+    // Parallel for HLS VIDEO-RANGE as defined in DASH-IF IOP v4.3 6.2.5.1.
+    let videoRange;
+    const videoRangeScheme = 'urn:mpeg:mpegB:cicp:TransferCharacteristics';
+    const getVideoRangeFromTransferCharacteristicCICP = (cicp) => {
+      switch (cicp) {
+        case 1:
+        case 6:
+        case 13:
+        case 14:
+        case 15:
+          return 'SDR';
+        case 16:
+          return 'PQ';
+        case 18:
+          return 'HLG';
+      }
+      return undefined;
+    };
+
     const essentialProperties =
         XmlUtils.findChildren(elem, 'EssentialProperty');
     // ID of real AdaptationSet if this is a trick mode set:
@@ -817,11 +894,26 @@ shaka.dash.DashParser = class {
       const schemeId = prop.getAttribute('schemeIdUri');
       if (schemeId == 'http://dashif.org/guidelines/trickmode') {
         trickModeFor = prop.getAttribute('value');
+      } else if (schemeId == videoRangeScheme) {
+        videoRange = getVideoRangeFromTransferCharacteristicCICP(
+            parseInt(prop.getAttribute('value'), 10),
+        );
       } else {
         unrecognizedEssentialProperty = true;
       }
     }
 
+    const supplementalProperties =
+        XmlUtils.findChildren(elem, 'SupplementalProperty');
+    for (const prop of supplementalProperties) {
+      const schemeId = prop.getAttribute('schemeIdUri');
+      if (schemeId == videoRangeScheme) {
+        videoRange = getVideoRangeFromTransferCharacteristicCICP(
+            parseInt(prop.getAttribute('value'), 10),
+        );
+      }
+    }
+
     const accessibilities = XmlUtils.findChildren(elem, 'Accessibility');
     const LanguageUtils = shaka.util.LanguageUtils;
     const closedCaptions = new Map();
@@ -858,7 +950,9 @@ shaka.dash.DashParser = class {
               channel = channelAndLanguage[0].startsWith('CC') ?
                   channelAndLanguage[0] : `CC${channelAndLanguage[0]}`;
 
-              language = channelAndLanguage[1]; // 3 letters (ISO 639-2)
+              // 3 letters (ISO 639-2).  In b/187442669, we saw a blank string
+              // (CC2=;CC3=), so default to "und" (the code for "undetermined").
+              language = channelAndLanguage[1] || 'und';
             }
             closedCaptions.set(channel, LanguageUtils.normalize(language));
           }
@@ -945,8 +1039,13 @@ shaka.dash.DashParser = class {
     // Parse Representations into Streams.
     const representations = XmlUtils.findChildren(elem, 'Representation');
     const streams = representations.map((representation) => {
-      return this.parseRepresentation_(context, contentProtection, kind,
-          language, label, main, roleValues, closedCaptions, representation);
+      const parsedRepresentation = this.parseRepresentation_(context,
+          contentProtection, kind, language, label, main, roleValues,
+          closedCaptions, representation);
+      if (parsedRepresentation) {
+        parsedRepresentation.hdr = parsedRepresentation.hdr || videoRange;
+      }
+      return parsedRepresentation;
     }).filter((s) => !!s);
 
     if (streams.length == 0) {
@@ -1122,8 +1221,10 @@ shaka.dash.DashParser = class {
 
     let forced = false;
     if (isText) {
-      // See: https://github.com/google/shaka-player/issues/2122
-      forced = roles.includes('forced_subtitle');
+      // See: https://github.com/google/shaka-player/issues/2122 and
+      // https://github.com/Dash-Industry-Forum/DASH-IF-IOP/issues/165
+      forced = roles.includes('forced_subtitle') ||
+          roles.includes('forced-subtitle');
     }
 
     let tilesLayout;
@@ -1637,9 +1738,10 @@ shaka.dash.DashParser = class {
    * @param {number} periodStart
    * @param {?number} periodDuration
    * @param {!Element} elem
+   * @param {number} availabilityStart
    * @private
    */
-  parseEventStream_(periodStart, periodDuration, elem) {
+  parseEventStream_(periodStart, periodDuration, elem, availabilityStart) {
     const XmlUtils = shaka.util.XmlUtils;
     const parseNumber = XmlUtils.parseNonNegativeInt;
 
@@ -1662,6 +1764,11 @@ shaka.dash.DashParser = class {
         endTime = Math.min(endTime, periodStart + periodDuration);
       }
 
+      // Don't add unavailable regions to the timeline.
+      if (endTime < availabilityStart) {
+        continue;
+      }
+
       /** @type {shaka.extern.TimelineRegionInfo} */
       const region = {
         schemeIdUri: schemeIdUri,

package/lib/dash/segment_list.js

@@ -63,12 +63,12 @@ shaka.dash.SegmentList = class {
       const start = context.presentationTimeline.getSegmentAvailabilityStart();
       segmentIndex.mergeAndEvict(references, start);
     } else {
-      context.presentationTimeline.notifySegments(references);
       segmentIndex = new shaka.media.SegmentIndex(references);
       if (id && context.dynamic) {
         segmentIndexMap[id] = segmentIndex;
       }
     }
+    context.presentationTimeline.notifySegments(references);
 
     if (!context.dynamic || !context.periodInfo.isLastPeriod) {
       const periodStart = context.periodInfo.start;

package/lib/dash/segment_template.js

@@ -116,12 +116,12 @@ shaka.dash.SegmentTemplate = class {
         segmentIndex.mergeAndEvict(references,
             context.presentationTimeline.getSegmentAvailabilityStart());
       } else {
-        context.presentationTimeline.notifySegments(references);
         segmentIndex = new shaka.media.SegmentIndex(references);
         if (id && context.dynamic) {
           segmentIndexMap[id] = segmentIndex;
         }
       }
+      context.presentationTimeline.notifySegments(references);
 
       if (shouldFit) {
         segmentIndex.fit(periodStart, periodEnd);

package/lib/hls/hls_parser.js

@@ -414,18 +414,16 @@ shaka.hls.HlsParser = class {
       const uri = tag.getAttributeValue('URI');
       const language = tag.getAttributeValue('LANGUAGE');
       const value = tag.getAttributeValue('VALUE');
-      const data = {
-        'id': id,
-      };
+      const data = (new Map()).set('id', id);
       if (uri) {
-        data.uri =
-            shaka.hls.Utils.constructAbsoluteUri(this.masterPlaylistUri_, uri);
+        data.set('uri',
+            shaka.hls.Utils.constructAbsoluteUri(this.masterPlaylistUri_, uri));
       }
       if (language) {
-        data.language = language;
+        data.set('language', language);
       }
       if (value) {
-        data.value = value;
+        data.set('value', value);
       }
       const event = new shaka.util.FakeEvent('sessiondata', data);
       if (this.playerInterface_) {
@@ -529,6 +527,30 @@ shaka.hls.HlsParser = class {
       }
     }
 
+    // Now that the content has been fit, notify segments.
+    this.segmentsToNotifyByStream_ = [];
+    const streamsToNotify = [];
+    for (const variant of variants) {
+      for (const stream of [variant.video, variant.audio]) {
+        if (stream) {
+          streamsToNotify.push(stream);
+        }
+      }
+    }
+    await Promise.all(streamsToNotify.map(async (stream) => {
+      await stream.createSegmentIndex();
+    }));
+    for (const stream of streamsToNotify) {
+      this.segmentsToNotifyByStream_.push(stream.segmentIndex.references);
+    }
+    this.notifySegments_();
+
+    // This asserts that the live edge is being calculated from segment times.
+    // For VOD and event streams, this check should still pass.
+    goog.asserts.assert(
+        !this.presentationTimeline_.usingPresentationStartTime(),
+        'We should not be using the presentation start time in HLS!');
+
     this.manifest_ = {
       presentationTimeline: this.presentationTimeline_,
       variants,
@@ -1151,7 +1173,7 @@ shaka.hls.HlsParser = class {
     // "AUTOSELECT=YES".  A value of "AUTOSELECT=NO" would imply that it may
     // only be selected explicitly by the user, and we don't have a way to
     // represent that in our model.
-    const defaultAttrValue = tag.getAttribute('DEFAULT');
+    const defaultAttrValue = tag.getAttributeValue('DEFAULT');
     const primary = defaultAttrValue == 'YES';
 
     const channelsCount = type == 'audio' ? this.getChannelsCount_(tag) : null;
@@ -1538,12 +1560,6 @@ shaka.hls.HlsParser = class {
     }
 
     this.notifySegments_();
-
-    // This asserts that the live edge is being calculated from segment times.
-    // For VOD and event streams, this check should still pass.
-    goog.asserts.assert(
-        !this.presentationTimeline_.usingPresentationStartTime(),
-        'We should not be using the presentation start time in HLS!');
   }
 
   /**
@@ -1915,9 +1931,6 @@ shaka.hls.HlsParser = class {
       }
     }
 
-    this.segmentsToNotifyByStream_.push(references);
-    this.notifySegments_();
-
     return references;
   }
 
@@ -2253,6 +2266,12 @@ shaka.hls.HlsParser = class {
       reader.rewind(1);
     };
 
+    // We will look a few packet-lengths forward to find the first sync byte.
+    // Note that we are using this method on what is already a subset of the
+    // file (the first |shaka.hls.HlsParser.START_OF_SEGMENT_SIZE_| bytes), so
+    // we can't look too far ahead to begin with.
+    let syncByteScanLength = Math.min(reader.getLength() - 188, 5 * 188);
+
     // TODO: refactor this while loop for better readability.
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -2261,8 +2280,16 @@ shaka.hls.HlsParser = class {
 
       syncByte = reader.readUint8();
       if (syncByte != 0x47) {
+        if (syncByteScanLength > 0) {
+          // This file could have started with a cut-off TS packet. Scan forward
+          // until we find a sync byte.
+          syncByteScanLength -= 1;
+          continue;
+        }
         fail();
       }
+      // If we've found a sync byte, stop scanning forward for future packets.
+      syncByteScanLength = 0;
 
       const flagsAndPacketId = reader.readUint16();
       const packetId = flagsAndPacketId & 0x1fff;

package/lib/hls/manifest_text_parser.js

@@ -277,6 +277,7 @@ shaka.hls.ManifestTextParser = class {
         const attrValue = blockAttrs[2] || blockAttrs[3];
         const attribute = new shaka.hls.Attribute(attrName, attrValue);
         attributes.push(attribute);
+        parser.skipWhitespace();
       }
     }
 

package/lib/media/closed_caption_parser.js

@@ -87,7 +87,9 @@ shaka.media.ClosedCaptionParser = class {
     for (const captionPacket of captionPackets) {
       const uint8ArrayData =
           shaka.util.BufferUtils.toUint8(captionPacket.packet);
-      this.ceaDecoder_.extract(uint8ArrayData, captionPacket.pts);
+      if (uint8ArrayData.length > 0) {
+        this.ceaDecoder_.extract(uint8ArrayData, captionPacket.pts);
+      }
     }
 
     // Decode and return the parsed captions.

package/lib/media/content_workarounds.js

@@ -75,6 +75,18 @@ shaka.media.ContentWorkarounds = class {
             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
           });
         })
+        .fullBox('avc3', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
+          });
+        })
+        .fullBox('ac-3', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCA_,
+          });
+        })
         .fullBox('ec-3', (box) => {
           boxesToModify.push({
             box,

package/lib/media/drm_engine.js

@@ -126,6 +126,9 @@ shaka.media.DrmEngine = class {
 
     /** @const {!shaka.util.Destroyer} */
     this.destroyer_ = new shaka.util.Destroyer(() => this.destroyNow_());
+
+    /** @private {boolean} */
+    this.srcEquals_ = false;
   }
 
   /** @override */
@@ -181,6 +184,7 @@ shaka.media.DrmEngine = class {
     this.config_ = null;
     this.onError_ = () => {};
     this.playerInterface_ = null;
+    this.srcEquals_ = false;
   }
 
   /**
@@ -194,6 +198,13 @@ shaka.media.DrmEngine = class {
     this.config_ = config;
   }
 
+  /**
+   * @param {!boolean} value
+   */
+  setSrcEquals(value) {
+    this.srcEquals_ = value;
+  }
+
   /**
    * Initialize the drm engine for storing and deleting stored content.
    *
@@ -356,7 +367,7 @@ shaka.media.DrmEngine = class {
     // in the drm infos, and before queryMediaKeys_().
     if (useMediaCapabilities) {
       await shaka.util.StreamUtils.getDecodingInfosForVariants(variants,
-          this.usePersistentLicenses_);
+          this.usePersistentLicenses_, this.srcEquals_);
     } else {
       configsByKeySystem =
           this.prepareMediaKeyConfigsForVariants_(variants);
@@ -512,6 +523,7 @@ shaka.media.DrmEngine = class {
     tasks.push(session.remove());
 
     await Promise.all(tasks);
+    this.activeSessions_.delete(session);
   }
 
   /**
@@ -1877,9 +1889,16 @@ shaka.media.DrmEngine = class {
         // audio adaptations, so we shouldn't have to worry about checking
         // robustness.
         if (drm1.keySystem == drm2.keySystem) {
+          /** @type {Array<shaka.extern.InitDataOverride>} */
           let initData = [];
           initData = initData.concat(drm1.initData || []);
           initData = initData.concat(drm2.initData || []);
+          initData = initData.filter((d, i) => {
+            return d.keyId === undefined || i === initData.findIndex((d2) => {
+              return d2.keyId === d.keyId;
+            });
+          });
+
           const keyIds = drm1.keyIds && drm2.keyIds ?
               new Set([...drm1.keyIds, ...drm2.keyIds]) :
               drm1.keyIds || drm2.keyIds;