shaka-player 3.1.3 → 3.1.4

package/docs/tutorials/fairplay.md

@@ -31,7 +31,7 @@ player.configure('drm.initDataTransform', (initData, initDataType) => {
 
   // 'initData' is a buffer containing an 'skd://' URL as a UTF-8 string.
   const skdUri = shaka.util.StringUtils.fromBytesAutoDetect(initData);
-  const contentId = getMyContentId(sdkUri);
+  const contentId = getMyContentId(skdUri);
   const cert = player.drmInfo().serverCertificate;
   return shaka.util.FairPlayUtils.initDataTransform(initData, contentId, cert);
 });

package/karma.conf.js

@@ -140,6 +140,7 @@ module.exports = (config) => {
         included: false,
       },
       {pattern: 'test/test/assets/*', included: false},
+      {pattern: 'test/test/assets/3675/*', included: false},
       {pattern: 'dist/shaka-player.ui.js', included: false},
       {pattern: 'dist/locales.js', included: false},
       {pattern: 'demo/locales/en.json', included: false},

package/lib/ads/client_side_ad_manager.js

@@ -138,7 +138,7 @@ shaka.ads.ClientSideAdManager = class {
     // Remove ad breaks from the timeline
     this.onEvent_(
         new shaka.util.FakeEvent(shaka.ads.AdManager.CUEPOINTS_CHANGED,
-            {'cuepoints': []}));
+            (new Map()).set('cuepoints', [])));
   }
 
 
@@ -151,17 +151,14 @@ shaka.ads.ClientSideAdManager = class {
 
     const now = Date.now() / 1000;
     const loadTime = now - this.requestAdsStartTime_;
-    this.onEvent_(
-        new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
-            {'loadTime': loadTime}));
+    this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
+        (new Map()).set('loadTime', loadTime)));
 
     this.imaAdsManager_ = e.getAdsManager(this.video_);
 
     this.onEvent_(new shaka.util.FakeEvent(
         shaka.ads.AdManager.IMA_AD_MANAGER_LOADED,
-        {
-          'imaAdManager': this.imaAdsManager_,
-        }));
+        (new Map()).set('imaAdManager', this.imaAdsManager_)));
 
     const cuePointStarts = this.imaAdsManager_.getCuePoints();
     if (cuePointStarts.length) {
@@ -172,9 +169,9 @@ shaka.ads.ClientSideAdManager = class {
         cuePoints.push(shakaCuePoint);
       }
 
-      this.onEvent_(
-          new shaka.util.FakeEvent(shaka.ads.AdManager.CUEPOINTS_CHANGED,
-              {'cuepoints': cuePoints}));
+      this.onEvent_(new shaka.util.FakeEvent(
+          shaka.ads.AdManager.CUEPOINTS_CHANGED,
+          (new Map()).set('cuepoints', cuePoints)));
     }
 
     this.addImaEventListeners_();
@@ -224,6 +221,15 @@ shaka.ads.ClientSideAdManager = class {
    * @private
    */
   addImaEventListeners_() {
+    /**
+     * @param {!Event} e
+     * @param {string} type
+     */
+    const convertEventAndSend = (e, type) => {
+      const data = (new Map()).set('originalEvent', e);
+      this.onEvent_(new shaka.util.FakeEvent(type, data));
+    };
+
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdErrorEvent.Type.AD_ERROR, (error) => {
           this.onAdError_(/** @type {!google.ima.AdErrorEvent} */ (error));
@@ -241,30 +247,22 @@ shaka.ads.ClientSideAdManager = class {
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.FIRST_QUARTILE, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_FIRST_QUARTILE,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_FIRST_QUARTILE);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.MIDPOINT, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_MIDPOINT,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_MIDPOINT);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.THIRD_QUARTILE, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_THIRD_QUARTILE,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_THIRD_QUARTILE);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.COMPLETE, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_COMPLETE,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_COMPLETE);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
@@ -279,140 +277,102 @@ shaka.ads.ClientSideAdManager = class {
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.SKIPPED, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_SKIPPED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_SKIPPED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.VOLUME_CHANGED, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_VOLUME_CHANGED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_VOLUME_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.VOLUME_MUTED, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_MUTED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_MUTED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.PAUSED, (e) => {
           goog.asserts.assert(this.ad_ != null, 'Ad should not be null!');
           this.ad_.setPaused(true);
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_PAUSED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_PAUSED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.RESUMED, (e) => {
           goog.asserts.assert(this.ad_ != null, 'Ad should not be null!');
           this.ad_.setPaused(false);
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_RESUMED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_RESUMED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.SKIPPABLE_STATE_CHANGED, (e) => {
           goog.asserts.assert(this.ad_ != null, 'Ad should not be null!');
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_SKIP_STATE_CHANGED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_SKIP_STATE_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.CLICK, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_CLICKED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_CLICKED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_PROGRESS, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_PROGRESS,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_PROGRESS);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_BUFFERING, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_BUFFERING,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_BUFFERING);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.IMPRESSION, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_IMPRESSION,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_IMPRESSION);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.DURATION_CHANGE, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_DURATION_CHANGED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_DURATION_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.USER_CLOSE, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_CLOSED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_CLOSED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.LOADED, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_LOADED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_LOADED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.ALL_ADS_COMPLETED, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.ALL_ADS_COMPLETED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.ALL_ADS_COMPLETED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.LINEAR_CHANGED, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_LINEAR_CHANGED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_LINEAR_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_METADATA, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_METADATA,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_METADATA);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.LOG, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_RECOVERABLE_ERROR,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_RECOVERABLE_ERROR);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_BREAK_READY, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_BREAK_READY,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_BREAK_READY);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.INTERACTION, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_INTERACTION,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_INTERACTION);
         });
   }
 
@@ -426,12 +386,12 @@ shaka.ads.ClientSideAdManager = class {
 
     const imaAd = e.getAd();
     this.ad_ = new shaka.ads.ClientSideAd(imaAd, this.imaAdsManager_);
-    this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STARTED,
-        {
-          'ad': this.ad_,
-          'sdkAdObject': imaAd,
-          'originalEvent': e,
-        }));
+    const data = new Map()
+        .set('ad', this.ad_)
+        .set('sdkAdObject', imaAd)
+        .set('originalEvent', e);
+    this.onEvent_(new shaka.util.FakeEvent(
+        shaka.ads.AdManager.AD_STARTED, data));
     this.adContainer_.setAttribute('ad-active', 'true');
     this.video_.pause();
   }
@@ -442,7 +402,7 @@ shaka.ads.ClientSideAdManager = class {
    */
   onAdComplete_(e) {
     this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STOPPED,
-        {'originalEvent': e}));
+        (new Map()).set('originalEvent', e)));
     this.adContainer_.removeAttribute('ad-active');
     this.video_.play();
   }

package/lib/ads/server_side_ad_manager.js

@@ -77,9 +77,7 @@ shaka.ads.ServerSideAdManager = class {
 
     this.onEvent_(new shaka.util.FakeEvent(
         shaka.ads.AdManager.IMA_STREAM_MANAGER_LOADED,
-        {
-          'imaStreamManager': this.streamManager_,
-        }));
+        (new Map()).set('imaStreamManager', this.streamManager_)));
 
     // Events
     this.eventManager_.listen(this.streamManager_,
@@ -298,7 +296,7 @@ shaka.ads.ServerSideAdManager = class {
     }
 
     this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STARTED,
-        {'ad': this.ad_}));
+        (new Map()).set('ad', this.ad_)));
     this.adContainer_.setAttribute('ad-active', 'true');
   }
 
@@ -324,9 +322,8 @@ shaka.ads.ServerSideAdManager = class {
   onLoaded_(e) {
     const now = Date.now() / 1000;
     const loadTime = now - this.streamRequestStartTime_;
-    this.onEvent_(
-        new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
-            {'loadTime': loadTime}));
+    this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
+        (new Map()).set('loadTime', loadTime)));
 
     const streamData = e.getStreamData();
     const url = streamData.url;
@@ -386,8 +383,8 @@ shaka.ads.ServerSideAdManager = class {
       cuePoints.push(shakaCuePoint);
     }
 
-    this.onEvent_(
-        new shaka.util.FakeEvent(shaka.ads.AdManager.CUEPOINTS_CHANGED,
-            {'cuepoints': cuePoints}));
+    this.onEvent_(new shaka.util.FakeEvent(
+        shaka.ads.AdManager.CUEPOINTS_CHANGED,
+        (new Map()).set('cuepoints', cuePoints)));
   }
 };

package/lib/cast/cast_proxy.js

@@ -525,7 +525,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 +599,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

@@ -407,7 +407,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/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.
@@ -533,6 +545,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 +579,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 +646,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(
@@ -808,6 +860,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 +888,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();
@@ -947,8 +1033,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) {

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;
   }
 

package/lib/media/drm_engine.js

@@ -1889,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;