shaka-player 3.1.0 → 3.1.4

package/lib/ads/server_side_ad_manager.js

@@ -14,10 +14,12 @@ goog.provide('shaka.ads.ServerSideAdManager');
 goog.require('goog.asserts');
 goog.require('shaka.ads.ServerSideAd');
 goog.require('shaka.log');
+goog.require('shaka.util.IReleasable');
 
 
 /**
  * A class responsible for server-side ad interactions.
+ * @implements {shaka.util.IReleasable}
  */
 shaka.ads.ServerSideAdManager = class {
   /**
@@ -75,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_,
@@ -201,11 +201,27 @@ shaka.ads.ServerSideAdManager = class {
    * Resets the stream manager and removes any continuous polling.
    */
   stop() {
-    this.streamManager_.reset();
+    // TODO:
+    // For SS DAI streams, if a different asset gets unloaded as
+    // part of the process
+    // of loading a DAI asset, stream manager state gets reset and we
+    // don't get any ad events.
+    // We need to figure out if it makes sense to stop the SS
+    // manager on unload, and, if it does, find
+    // a way to do it safely.
+    // this.streamManager_.reset();
     this.backupUrl_ = '';
     this.snapForwardTime_ = null;
   }
 
+  /** @override */
+  release() {
+    this.stop();
+    if (this.eventManager_) {
+      this.eventManager_.release();
+    }
+  }
+
   /**
    * @param {string} type
    * @param {Uint8Array|string} data
@@ -280,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');
   }
 
@@ -306,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;
@@ -368,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/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

@@ -65,6 +65,12 @@ shaka.dash.DashParser = class {
      */
     this.segmentIndexMap_ = {};
 
+    /**
+     * A map of period ids to their durations
+     * @private {!Object.<string, number>}
+     */
+    this.periodDurations_ = {};
+
     /** @private {shaka.util.PeriodCombiner} */
     this.periodCombiner_ = new shaka.util.PeriodCombiner();
 
@@ -89,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.
@@ -527,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);
 
@@ -560,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,
@@ -570,6 +625,10 @@ shaka.dash.DashParser = class {
       const period = this.parsePeriod_(context, baseUris, info);
       periods.push(period);
 
+      if (context.period.id && periodDuration) {
+        this.periodDurations_[context.period.id] = periodDuration;
+      }
+
       if (periodDuration == null) {
         if (next) {
           // If the duration is still null and we aren't at the end, then we
@@ -587,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(
@@ -798,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:
@@ -807,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();
@@ -848,7 +944,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));
           }
@@ -935,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) {
@@ -1060,7 +1163,7 @@ shaka.dash.DashParser = class {
         const hasManifest = !!this.manifest_;
         streamInfo = shaka.dash.SegmentTemplate.createStreamInfo(
             context, requestInitSegment, this.segmentIndexMap_, hasManifest,
-            this.config_.dash.initialSegmentLimit);
+            this.config_.dash.initialSegmentLimit, this.periodDurations_);
       } else {
         goog.asserts.assert(isText,
             'Must have Segment* with non-text streams.');

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

@@ -35,11 +35,12 @@ shaka.dash.SegmentTemplate = class {
    * @param {boolean} isUpdate True if the manifest is being updated.
    * @param {number} segmentLimit The maximum number of segments to generate for
    *   a SegmentTemplate with fixed duration.
+   * @param {!Object.<string, number>} periodDurationMap
    * @return {shaka.dash.DashParser.StreamInfo}
    */
   static createStreamInfo(
       context, requestInitSegment, segmentIndexMap, isUpdate,
-      segmentLimit) {
+      segmentLimit, periodDurationMap) {
     goog.asserts.assert(context.representation.segmentTemplate,
         'Should only be called with SegmentTemplate');
     const SegmentTemplate = shaka.dash.SegmentTemplate;
@@ -77,7 +78,8 @@ shaka.dash.SegmentTemplate = class {
       return {
         generateSegmentIndex: () => {
           return SegmentTemplate.generateSegmentIndexFromDuration_(
-              shallowCopyOfContext, info, segmentLimit, initSegmentReference);
+              shallowCopyOfContext, info, segmentLimit, initSegmentReference,
+              periodDurationMap);
         },
       };
     } else {
@@ -114,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);
@@ -259,11 +261,12 @@ shaka.dash.SegmentTemplate = class {
    * @param {shaka.dash.SegmentTemplate.SegmentTemplateInfo} info
    * @param {number} segmentLimit The maximum number of segments to generate.
    * @param {shaka.media.InitSegmentReference} initSegmentReference
+   * @param {!Object.<string, number>} periodDurationMap
    * @return {!Promise.<shaka.media.SegmentIndex>}
    * @private
    */
   static generateSegmentIndexFromDuration_(
-      context, info, segmentLimit, initSegmentReference) {
+      context, info, segmentLimit, initSegmentReference, periodDurationMap) {
     goog.asserts.assert(info.mediaTemplate,
         'There should be a media template with duration');
 
@@ -275,9 +278,20 @@ shaka.dash.SegmentTemplate = class {
     // Capture values that could change as the parsing context moves on to
     // other parts of the manifest.
     const periodStart = context.periodInfo.start;
-    const periodDuration = context.periodInfo.duration;
-    const periodEnd = periodDuration ?
-        periodStart + periodDuration : Infinity;
+    const periodId = context.period.id;
+    const initialPeriodDuration = context.periodInfo.duration;
+
+    // For multi-period live streams the period duration may not be known until
+    // the following period appears in an updated manifest. periodDurationMap
+    // provides the updated period duration.
+    const getPeriodEnd = () => {
+      const periodDuration =
+        (periodId != null && periodDurationMap[periodId]) ||
+        initialPeriodDuration;
+      const periodEnd = periodDuration ?
+        (periodStart + periodDuration) : Infinity;
+      return periodEnd;
+    };
 
     const segmentDuration = info.segmentDuration;
     goog.asserts.assert(
@@ -304,7 +318,7 @@ shaka.dash.SegmentTemplate = class {
 
         Math.min(
             presentationTimeline.getSegmentAvailabilityEnd(),
-            periodEnd),
+            getPeriodEnd()),
       ];
     };
 
@@ -376,16 +390,17 @@ shaka.dash.SegmentTemplate = class {
 
       // Relative to the presentation.
       const segmentStart = segmentPeriodTime + periodStart;
+      const trueSegmentEnd = segmentStart + segmentDuration;
       // Cap the segment end at the period end so that references from the
       // next period will fit neatly after it.
-      const segmentEnd = Math.min(segmentStart + segmentDuration, periodEnd);
+      const segmentEnd = Math.min(trueSegmentEnd, getPeriodEnd());
 
       // This condition will be true unless the segmentStart was >= periodEnd.
       // If we've done the position calculations correctly, this won't happen.
       goog.asserts.assert(segmentStart < segmentEnd,
           'Generated a segment outside of the period!');
 
-      return new shaka.media.SegmentReference(
+      const ref = new shaka.media.SegmentReference(
           segmentStart,
           segmentEnd,
           getUris,
@@ -394,7 +409,10 @@ shaka.dash.SegmentTemplate = class {
           initSegmentReference,
           timestampOffset,
           /* appendWindowStart= */ periodStart,
-          /* appendWindowEnd= */ periodEnd);
+          /* appendWindowEnd= */ getPeriodEnd());
+      // This is necessary information for thumbnail streams:
+      ref.trueEndTime = trueSegmentEnd;
+      return ref;
     };
 
     for (let position = minPosition; position <= maxPosition; ++position) {
@@ -407,7 +425,15 @@ shaka.dash.SegmentTemplate = class {
 
     // If the availability timeline currently ends before the period, we will
     // need to add references over time.
-    if (presentationTimeline.getSegmentAvailabilityEnd() < periodEnd) {
+    const willNeedToAddReferences =
+        presentationTimeline.getSegmentAvailabilityEnd() < getPeriodEnd();
+
+    // When we start a live stream with a period that ends within the
+    // availability window we will not need to add more references, but we will
+    // need to evict old references.
+    const willNeedToEvictReferences = presentationTimeline.isLive();
+
+    if (willNeedToAddReferences || willNeedToEvictReferences) {
       // The period continues to get longer over time, so check for new
       // references once every |segmentDuration| seconds.
       // We clamp to |minPosition| in case the initial range was reversed and no
@@ -416,7 +442,9 @@ shaka.dash.SegmentTemplate = class {
       let nextPosition = Math.max(minPosition, maxPosition + 1);
       segmentIndex.updateEvery(segmentDuration, () => {
         // Evict any references outside the window.
-        segmentIndex.evict(presentationTimeline.getSegmentAvailabilityStart());
+        const availabilityStartTime =
+          presentationTimeline.getSegmentAvailabilityStart();
+        segmentIndex.evict(availabilityStartTime);
 
         // Compute any new references that need to be added.
         const [_, maxPosition] = computeAvailablePositionRange();
@@ -426,8 +454,10 @@ shaka.dash.SegmentTemplate = class {
           references.push(reference);
           nextPosition++;
         }
-        if (presentationTimeline.getSegmentAvailabilityEnd() >= periodEnd &&
-            !references.length) {
+
+        // The timer must continue firing until the entire period is
+        // unavailable, so that all references will be evicted.
+        if (availabilityStartTime > getPeriodEnd() && !references.length) {
           // Signal stop.
           return null;
         }

package/lib/dependencies/all.js

@@ -14,7 +14,7 @@ shaka.dependencies = class {
    * Registers a new dependency.
    *
    * @param {shaka.dependencies.Allowed} key which is used for retrieving a
-   * dependency
+   *   dependency
    * @param {?} dep a dependency
    * @export
    */
@@ -22,14 +22,15 @@ shaka.dependencies = class {
     if (!shaka.dependencies.Allowed[key]) {
       throw new Error(`${key} is not supported`);
     }
-    shaka.dependencies.dependencies_.set(key, dep);
+    shaka.dependencies.dependencies_.set(key, () => dep);
   }
 
   /**
-   * Check if we have a dependency for the key
-   * @export
+   * Check if we have a dependency for the key.
+   *
    * @param {shaka.dependencies.Allowed} key key
    * @return {boolean}
+   * @export
    */
   static has(key) {
     return shaka.dependencies.dependencies_.has(key);
@@ -38,16 +39,10 @@ shaka.dependencies = class {
   /** @return {?muxjs} */
   static muxjs() {
     return /** @type {?muxjs} */ (shaka.dependencies.dependencies_.get(
-        shaka.dependencies.Allowed.muxjs));
+        shaka.dependencies.Allowed.muxjs)());
   }
 };
 
-/**
- * Contains shared dependencies that could  be used by other components.
- * @private {!Map.<string, Object>}
- */
-shaka.dependencies.dependencies_ = new Map();
-
 /**
  * @export
  * @enum {string}
@@ -56,7 +51,12 @@ shaka.dependencies.Allowed = {
   muxjs: 'muxjs',
 };
 
-// Add global muxjs object for backward compatibility
-shaka.dependencies.dependencies_.set(
-    shaka.dependencies.Allowed.muxjs,
-    window.muxjs);
+/**
+ * Contains accessor functions to shared dependencies that could be used by
+ * other components.  The default accessors can be overridden.
+ *
+ * @private {!Map.<shaka.dependencies.Allowed, function():?>}
+ */
+shaka.dependencies.dependencies_ = new Map([
+  [shaka.dependencies.Allowed.muxjs, () => window.muxjs],
+]);