shaka-player 4.0.0 → 4.0.3

package/docs/tutorials/upgrade.md

@@ -42,10 +42,12 @@ application:
       `manifest.defaultPresentationDelay` (deprecated in v3.0.0)
     - Configuration of factories should be plain factory functions, not
       constructors; these will not be invoked with `new` (deprecated in v3.1.0)
-    - `drm.initDataTransform` has been removed (no longer needed since the
-      minimum supported version of iOS is now 13)
+    - `drm.initDataTransform` now defaults to a no-op
     - `streaming.smallGapLimit` and `streaming.jumpLargeGaps` have been removed;
       all gaps will now be jumped
+    - `manifest.hls.useFullSegmentsForStartTime` has been removed; this setting
+      is no longer necessary, as we no longer fetch segments for start times in
+      the HLS parser
 
   - Player API changes:
     - `shaka.Player.prototype.addTextTrack()` has been replaced by

package/externs/shaka/player.js

@@ -618,6 +618,9 @@ shaka.extern.AdvancedDrmConfiguration;
  *   clearKeys: !Object.<string, string>,
  *   delayLicenseRequestUntilPlayed: boolean,
  *   advanced: Object.<string, shaka.extern.AdvancedDrmConfiguration>,
+ *   initDataTransform:
+ *       ((function(!Uint8Array, string, ?shaka.extern.DrmInfo):!Uint8Array)|
+ *         undefined),
  *   logLicenseExchange: boolean,
  *   updateExpirationTime: number,
  *   preferredKeySystems: !Array.<string>
@@ -641,6 +644,14 @@ shaka.extern.AdvancedDrmConfiguration;
  *   <i>Optional.</i> <br>
  *   A dictionary which maps key system IDs to advanced DRM configuration for
  *   those key systems.
+ * @property
+ *     {((function(!Uint8Array, string, ?shaka.extern.DrmInfo):!Uint8Array)|
+ *        undefined)}
+ *   initDataTransform
+ *   <i>Optional.</i><br>
+ *   If given, this function is called with the init data from the
+ *   manifest/media and should return the (possibly transformed) init data to
+ *   pass to the browser.
  * @property {boolean} logLicenseExchange
  *   <i>Optional.</i><br>
  *   If set to <code>true</code>, prints logs containing the license exchange.
@@ -755,8 +766,10 @@ shaka.extern.DashManifestConfiguration;
  *   <i>Defaults to <code>'avc1.42E01E'</code>.</i>
  * @property {boolean} ignoreManifestProgramDateTime
  *   If <code>true</code>, the HLS parser will ignore the
- *   <code>EXT-X-PROGRAM-DATE-TIME</code> tags in the manifest.
- *   Meant for tags that are incorrect or malformed.
+ *   <code>EXT-X-PROGRAM-DATE-TIME</code> tags in the manifest and use media
+ *   sequence numbers instead.
+ *   Meant for streams where <code>EXT-X-PROGRAM-DATE-TIME</code> is incorrect
+ *   or malformed.
  *   <i>Defaults to <code>false</code>.</i>
  * @property {string} mediaPlaylistFullMimeType
  *   A string containing a full mime type, including both the basic mime type

package/karma.conf.js

@@ -363,6 +363,8 @@ module.exports = (config) => {
     // If testing custom assets, we don't serve other unit or integration tests.
     // External asset tests are the basis for custom asset testing, so this file
     // is automatically included.
+    clientArgs.testFiles.push('demo/common/asset.js');
+    clientArgs.testFiles.push('demo/common/assets.js');
     clientArgs.testFiles.push('test/player_external.js');
   } else {
     // In a normal test run, we serve unit tests.
@@ -374,6 +376,8 @@ module.exports = (config) => {
     }
     if (settings.external) {
       // If --external is present, we serve external asset tests.
+      clientArgs.testFiles.push('demo/common/asset.js');
+      clientArgs.testFiles.push('demo/common/assets.js');
       clientArgs.testFiles.push('test/**/*_external.js');
     }
   }

package/lib/abr/simple_abr_manager.js

@@ -219,8 +219,9 @@ shaka.abr.SimpleAbrManager = class {
    * @export
    */
   getBandwidthEstimate() {
+    const defaultBandwidthEstimate = this.getDefaultBandwidth_();
     return this.bandwidthEstimator_.getBandwidthEstimate(
-        this.config_.defaultBandwidthEstimate);
+        defaultBandwidthEstimate);
   }
 
 

package/lib/dash/dash_parser.js

@@ -765,8 +765,8 @@ shaka.dash.DashParser = class {
             // currently support that.  Just choose one.
             // TODO: https://github.com/shaka-project/shaka-player/issues/1528
             stream.trickModeVideo = trickModeSet.streams.find((trickStream) =>
-              shaka.util.MimeUtils.getCodecBase(stream.codecs) ==
-              shaka.util.MimeUtils.getCodecBase(trickStream.codecs));
+              shaka.util.MimeUtils.getNormalizedCodec(stream.codecs) ==
+              shaka.util.MimeUtils.getNormalizedCodec(trickStream.codecs));
           }
         }
       }

package/lib/hls/hls_parser.js

@@ -121,13 +121,19 @@ shaka.hls.HlsParser = class {
     this.updatePlaylistDelay_ = 0;
 
     /**
-     * A time offset to apply to EXT-X-PROGRAM-DATE-TIME values to normalize
-     * them so that they start at 0. This is necessary because these times will
-     * be used to set presentation times for segments.
-     * null means we don't have enough data yet.
+     * If true, we have already calculated offsets to synchronize streams.
+     * Offsets are computed in syncStreams*_().
+     * @private {boolean}
+     */
+    this.streamsSynced_ = false;
+
+    /**
+     * The minimum sequence number for generated segments, when ignoring
+     * EXT-X-PROGRAM-DATE-TIME.
+     *
      * @private {?number}
      */
-    this.syncTimeOffset_ = null;
+    this.minSequenceNumber_ = null;
 
     /**
      * This timer is used to trigger the start of a manifest update. A manifest
@@ -361,39 +367,155 @@ shaka.hls.HlsParser = class {
   }
 
   /**
-   * If necessary, makes sure that sync times will be normalized to 0, so that
-   * a stream does not start buffering at 50 years in because sync times are
-   * measured in time since 1970.
+   * Align all streams by sequence number by dropping early segments.  Then
+   * offset all streams to begin at presentation time 0.
    * @private
    */
-  calculateSyncTimeOffset_() {
-    if (this.syncTimeOffset_ != null) {
-      // The offset was already calculated.
+  syncStreamsWithSequenceNumber_() {
+    if (this.streamsSynced_) {
       return;
     }
 
-    const segments = new Set();
-    let lowestSyncTime = Infinity;
+    // Sync using media sequence number.  Find the highest starting sequence
+    // number among all streams.  Later, we will drop any references to
+    // earlier segments in other streams, then offset everything back to 0.
+    let highestStartingSequenceNumber = -1;
+    const firstSequenceNumberMap = new Map();
+
     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
       const segmentIndex = streamInfo.stream.segmentIndex;
       if (segmentIndex) {
-        segmentIndex.forEachTopLevelReference((segment) => {
-          if (segment.syncTime != null) {
-            lowestSyncTime = Math.min(lowestSyncTime, segment.syncTime);
-            segments.add(segment);
+        const segment0 = segmentIndex.earliestReference();
+        if (segment0) {
+          // This looks inefficient, but iteration order is insertion order.
+          // So the very first entry should be the one we want.
+          // We assert that this holds true so that we are alerted by debug
+          // builds and tests if it changes.  We still do a loop, though, so
+          // that the code functions correctly in production no matter what.
+          if (goog.DEBUG) {
+            const firstSequenceStartTime =
+                streamInfo.mediaSequenceToStartTime.values().next().value;
+            goog.asserts.assert(
+                firstSequenceStartTime == segment0.startTime,
+                'Sequence number map is not ordered as expected!');
           }
-        });
+          for (const [sequence, start] of streamInfo.mediaSequenceToStartTime) {
+            if (start == segment0.startTime) {
+              firstSequenceNumberMap.set(streamInfo, sequence);
+
+              highestStartingSequenceNumber = Math.max(
+                  highestStartingSequenceNumber, sequence);
+              break;
+            }
+          }
+        }
       }
     }
-    if (segments.size > 0) {
-      this.syncTimeOffset_ = -lowestSyncTime;
-      for (const segment of segments) {
-        segment.syncTime += this.syncTimeOffset_;
-        for (const partial of segment.partialReferences) {
-          partial.syncTime += this.syncTimeOffset_;
+
+    if (highestStartingSequenceNumber < 0) {
+      // Nothing to sync.
+      return;
+    }
+
+    // From now on, updates will ignore any references before this number.
+    this.minSequenceNumber_ = highestStartingSequenceNumber;
+
+    shaka.log.debug('Syncing HLS streams against base sequence number:',
+        this.minSequenceNumber_);
+
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      const segmentIndex = streamInfo.stream.segmentIndex;
+      if (segmentIndex) {
+        // Drop any earlier references.
+        const numSegmentsToDrop = this.minSequenceNumber_ -
+            firstSequenceNumberMap.get(streamInfo);
+        segmentIndex.dropFirstReferences(numSegmentsToDrop);
+
+        // Now adjust timestamps back to begin at 0.
+        const segmentN = segmentIndex.earliestReference();
+        if (segmentN) {
+          this.offsetStream_(streamInfo, -segmentN.startTime);
+        }
+      }
+    }
+
+    this.streamsSynced_ = true;
+  }
+
+  /**
+   * Synchronize streams by the EXT-X-PROGRAM-DATE-TIME tags attached to their
+   * segments.  Also normalizes segment times so that the earliest segment in
+   * any stream is at time 0.
+   * @private
+   */
+  syncStreamsWithProgramDateTime_() {
+    if (this.streamsSynced_) {
+      return;
+    }
+
+    let lowestSyncTime = Infinity;
+
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      const segmentIndex = streamInfo.stream.segmentIndex;
+      if (segmentIndex) {
+        const segment0 = segmentIndex.earliestReference();
+        if (segment0 != null && segment0.syncTime != null) {
+          lowestSyncTime = Math.min(lowestSyncTime, segment0.syncTime);
+        }
+      }
+    }
+
+    if (lowestSyncTime == Infinity) {
+      // Nothing to sync.
+      return;
+    }
+
+    shaka.log.debug('Syncing HLS streams against base time:', lowestSyncTime);
+
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      const segmentIndex = streamInfo.stream.segmentIndex;
+      if (segmentIndex != null) {
+        const segment0 = segmentIndex.earliestReference();
+        if (segment0.syncTime == null) {
+          shaka.log.alwaysError('Missing EXT-X-PROGRAM-DATE-TIME for stream',
+              streamInfo.verbatimMediaPlaylistUri,
+              'Expect AV sync issues!');
+        } else {
+          // The first segment's target startTime should be based entirely on
+          // its syncTime.  The rest of the stream will be based on that
+          // starting point.  The earliest segment sync time from any stream
+          // will become presentation time 0.  If two streams start e.g. 6
+          // seconds apart in syncTime, then their first segments will also
+          // start 6 seconds apart in presentation time.
+          const segment0TargetTime = segment0.syncTime - lowestSyncTime;
+          const streamOffset = segment0TargetTime - segment0.startTime;
+
+          this.offsetStream_(streamInfo, streamOffset);
         }
       }
     }
+
+    this.streamsSynced_ = true;
+  }
+
+  /**
+   * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
+   * @param {number} offset
+   * @private
+   */
+  offsetStream_(streamInfo, offset) {
+    streamInfo.stream.segmentIndex.offset(offset);
+
+    streamInfo.maxTimestamp += offset;
+    goog.asserts.assert(streamInfo.maxTimestamp >= 0,
+        'Negative maxTimestamp after adjustment!');
+
+    for (const [key, value] of streamInfo.mediaSequenceToStartTime) {
+      streamInfo.mediaSequenceToStartTime.set(key, value + offset);
+    }
+
+    shaka.log.debug('Offset', offset, 'applied to',
+        streamInfo.verbatimMediaPlaylistUri);
   }
 
   /**
@@ -524,7 +646,11 @@ shaka.hls.HlsParser = class {
 
     // Now that we have generated all streams, we can determine the offset to
     // apply to sync times.
-    this.calculateSyncTimeOffset_();
+    if (this.config_.hls.ignoreManifestProgramDateTime) {
+      this.syncStreamsWithSequenceNumber_();
+    } else {
+      this.syncStreamsWithProgramDateTime_();
+    }
 
     if (this.aesEncrypted_ && variants.length == 0) {
       // We do not support AES-128 encryption with HLS yet. Variants is null
@@ -539,15 +665,12 @@ shaka.hls.HlsParser = class {
 
     // Find the min and max timestamp of the earliest segment in all streams.
     // Find the minimum duration of all streams as well.
-    let minFirstTimestamp = Infinity;
     let minDuration = Infinity;
-
     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
-      minFirstTimestamp =
-          Math.min(minFirstTimestamp, streamInfo.minTimestamp);
       if (streamInfo.stream.type != 'text') {
-        minDuration = Math.min(minDuration,
-            streamInfo.maxTimestamp - streamInfo.minTimestamp);
+        // Since everything is already offset to 0 (either by sync or by being
+        // VOD), only maxTimestamp is necessary to compute the duration.
+        minDuration = Math.min(minDuration, streamInfo.maxTimestamp);
       }
     }
 
@@ -591,18 +714,11 @@ shaka.hls.HlsParser = class {
             segmentAvailabilityDuration);
       }
     } else {
-      // For VOD/EVENT content, offset everything back to 0.
-      // Use the minimum timestamp as the offset for all streams.
       // Use the minimum duration as the presentation duration.
       this.presentationTimeline_.setDuration(minDuration);
-      // Use a negative offset to adjust towards 0.
-      this.presentationTimeline_.offset(-minFirstTimestamp);
 
       for (const streamInfo of this.uriToStreamInfosMap_.values()) {
-        // The segments were created with actual media times, rather than
-        // presentation-aligned times, so offset them all now.
-        streamInfo.stream.segmentIndex.offset(-minFirstTimestamp);
-        // Finally, fit the segments to the playlist duration.
+        // Fit the segments to the playlist duration.
         streamInfo.stream.segmentIndex.fit(/* periodStart= */ 0, minDuration);
       }
     }
@@ -810,12 +926,7 @@ shaka.hls.HlsParser = class {
     });
 
     // Create stream info for each audio / video media tag.
-    // Wait for the first stream info created, so that the start time is fetched
-    // and can be reused.
-    if (mediaTags.length) {
-      await this.createStreamInfoFromMediaTag_(mediaTags[0]);
-    }
-    const promises = mediaTags.slice(1).map((tag) => {
+    const promises = mediaTags.map((tag) => {
       return this.createStreamInfoFromMediaTag_(tag);
     });
     await Promise.all(promises);
@@ -1583,7 +1694,6 @@ shaka.hls.HlsParser = class {
       throw error;
     }
 
-    const minTimestamp = segments[0].startTime;
     const lastEndTime = segments[segments.length - 1].endTime;
     /** @type {!shaka.media.SegmentIndex} */
     const segmentIndex = new shaka.media.SegmentIndex(segments);
@@ -1641,7 +1751,6 @@ shaka.hls.HlsParser = class {
       stream,
       verbatimMediaPlaylistUri,
       absoluteMediaPlaylistUri,
-      minTimestamp,
       maxTimestamp: lastEndTime,
       mediaSequenceToStartTime,
       canSkipSegments,
@@ -1825,7 +1934,7 @@ shaka.hls.HlsParser = class {
    * @param {!Map.<string, string>} variables
    * @param {string} absoluteMediaPlaylistUri
    * @param {string} type
-   * @return {!shaka.media.SegmentReference}
+   * @return {shaka.media.SegmentReference}
    * @private
    */
   createSegmentReference_(
@@ -1853,15 +1962,9 @@ shaka.hls.HlsParser = class {
       const dateTimeTag =
           shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-PROGRAM-DATE-TIME');
       if (dateTimeTag && dateTimeTag.value) {
-        const time = shaka.util.XmlUtils.parseDate(dateTimeTag.value);
-        goog.asserts.assert(time != null,
+        syncTime = shaka.util.XmlUtils.parseDate(dateTimeTag.value);
+        goog.asserts.assert(syncTime != null,
             'EXT-X-PROGRAM-DATE-TIME format not valid');
-        // Sync time offset is null on the first go-through. This indicates that
-        // we have not yet seen every stream, and thus do not yet have enough
-        // information to determine how to normalize the sync times.
-        // For that first go-through, the sync time will be applied after the
-        // references are all created. Until then, just offset by 0.
-        syncTime = time + (this.syncTimeOffset_ || 0);
       }
     }
 
@@ -1870,17 +1973,42 @@ shaka.hls.HlsParser = class {
       status = shaka.media.SegmentReference.Status.MISSING;
     }
 
+    if (!extinfTag) {
+      if (hlsSegment.partialSegments.length == 0) {
+        // EXTINF tag must be available if the segment has no partial segments.
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MANIFEST,
+            shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, 'EXTINF');
+      } else if (!this.lowLatencyMode_) {
+        // Without EXTINF and without low-latency mode, partial segments get
+        // ignored.
+        return null;
+      }
+    }
+
     // Create SegmentReferences for the partial segments.
     const partialSegmentRefs = [];
-    if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
+    if (this.lowLatencyMode_) {
       for (let i = 0; i < hlsSegment.partialSegments.length; i++) {
         const item = hlsSegment.partialSegments[i];
         const pPreviousReference = i == 0 ?
           previousReference : partialSegmentRefs[partialSegmentRefs.length - 1];
         const pStartTime = (i == 0) ? startTime : pPreviousReference.endTime;
-        const pDuration = Number(item.getAttributeValue('DURATION'));
-        // A preload hinted partial segment doesn't have duration information,
-        // so its startTime and endTime are the same.
+
+        // If DURATION is missing from this partial segment, use the target
+        // partial duration from the top of the playlist, which is a required
+        // attribute for content with partial segments.
+        const pDuration = Number(item.getAttributeValue('DURATION')) ||
+            this.partialTargetDuration_;
+
+        // If for some reason we have neither an explicit duration, nor a target
+        // partial duration, we should SKIP this partial segment to avoid
+        // duplicating content in the presentation timeline.
+        if (!pDuration) {
+          continue;
+        }
+
         const pEndTime = pStartTime + pDuration;
 
         let pStartByte = 0;
@@ -1913,14 +2041,6 @@ shaka.hls.HlsParser = class {
             /* appendWindowEnd= */ Infinity);
         partialSegmentRefs.push(partial);
       } // for-loop of hlsSegment.partialSegments
-    } else {
-      // EXTINF tag must be available if the segment has no partial segments.
-      if (!extinfTag) {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.MANIFEST,
-            shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, 'EXTINF');
-      }
     }
 
     // If the segment has EXTINF tag, set the segment's end time, start byte
@@ -1939,6 +2059,7 @@ shaka.hls.HlsParser = class {
     } else {
       endTime = partialSegmentRefs[partialSegmentRefs.length - 1].endTime;
     }
+
     // If the segment has EXT-X-BYTERANGE tag, set the start byte and end byte
     // base on the byterange information. If segment has no EXT-X-BYTERANGE tag
     // and has partial segments, set the start byte and end byte base on the
@@ -2067,16 +2188,13 @@ shaka.hls.HlsParser = class {
       firstStartTime = mediaSequenceToStartTime.get(position);
     }
 
-    const firstSegmentUri = hlsSegments[0].absoluteUri;
-    shaka.log.debug('First segment', firstSegmentUri.split('/').pop(),
-        'starts at', firstStartTime);
-
     /** @type {!Array.<!shaka.media.SegmentReference>} */
     const references = [];
 
+    let previousReference = null;
+
     for (let i = 0; i < hlsSegments.length; i++) {
       const item = hlsSegments[i];
-      const previousReference = references[references.length - 1];
       const startTime =
           (i == 0) ? firstStartTime : previousReference.endTime;
       position = mediaSequenceNumber + skippedSegments + i;
@@ -2106,8 +2224,18 @@ shaka.hls.HlsParser = class {
           variables,
           playlist.absoluteUri,
           type);
-
-      references.push(reference);
+      previousReference = reference;
+
+      if (reference) {
+        if (this.config_.hls.ignoreManifestProgramDateTime &&
+            this.minSequenceNumber_ != null &&
+            position < this.minSequenceNumber_) {
+          // This segment is ignored as part of our fallback synchronization
+          // method.
+        } else {
+          references.push(reference);
+        }
+      }
     }
 
     // If some segments have sync times, but not all, extrapolate the sync
@@ -2236,12 +2364,16 @@ shaka.hls.HlsParser = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
+    // If you wait long enough, requesting the first segment can fail
+    // because it has fallen off the left edge of DVR, so to be safer,
+    // let's request the middle segment.
     goog.asserts.assert(playlist.segments.length,
         'Playlist should have segments!');
-    const firstSegmentUri = this.variableSubstitution_(
-        playlist.segments[0].absoluteUri, variables);
+    const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
+    const middleSegmentUri = this.variableSubstitution_(
+        playlist.segments[middleSegmentIdx].absoluteUri, variables);
 
-    const parsedUri = new goog.Uri(firstSegmentUri);
+    const parsedUri = new goog.Uri(middleSegmentUri);
     const extension = parsedUri.getPath().split('.').pop();
     const map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
 
@@ -2271,7 +2403,7 @@ shaka.hls.HlsParser = class {
     // If unable to guess mime type, request a segment and try getting it
     // from the response.
     const headRequest = shaka.net.NetworkingEngine.makeRequest(
-        [firstSegmentUri], this.config_.retryParameters);
+        [middleSegmentUri], this.config_.retryParameters);
     headRequest.method = 'HEAD';
 
     const response = await this.makeNetworkRequest_(
@@ -2558,7 +2690,6 @@ shaka.hls.HlsParser = class {
  *   stream: !shaka.extern.Stream,
  *   verbatimMediaPlaylistUri: string,
  *   absoluteMediaPlaylistUri: string,
- *   minTimestamp: number,
  *   maxTimestamp: number,
  *   mediaSequenceToStartTime: !Map.<number, number>,
  *   canSkipSegments: boolean
@@ -2577,8 +2708,6 @@ shaka.hls.HlsParser = class {
  * @property {string} absoluteMediaPlaylistUri
  *   The absolute media playlist URI, resolved relative to the master playlist
  *   and updated to reflect any redirects.
- * @property {number} minTimestamp
- *   The minimum timestamp found in the stream.
  * @property {number} maxTimestamp
  *   The maximum timestamp found in the stream.
  * @property {!Map.<number, number>} mediaSequenceToStartTime

package/lib/media/drm_engine.js

@@ -1253,6 +1253,22 @@ shaka.media.DrmEngine = class {
     };
     this.activeSessions_.set(session, metadata);
 
+    try {
+      initData = this.config_.initDataTransform(
+          initData, initDataType, this.currentDrmInfo_);
+    } catch (error) {
+      let shakaError = error;
+      if (!(error instanceof shaka.util.Error)) {
+        shakaError = new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.DRM,
+            shaka.util.Error.Code.INIT_DATA_TRANSFORM_ERROR,
+            error);
+      }
+      this.onError_(shakaError);
+      return;
+    }
+
     if (this.config_.logLicenseExchange) {
       const str = shaka.util.Uint8ArrayUtils.toBase64(initData);
       shaka.log.info('EME init data: type=', initDataType, 'data=', str);
@@ -1408,6 +1424,9 @@ shaka.media.DrmEngine = class {
       }
       return;
     }
+    if (this.destroyer_.destroyed()) {
+      return;
+    }
 
     const updateEvent = new shaka.util.FakeEvent('drmsessionupdate');
     this.playerInterface_.onEvent(updateEvent);