shaka-player 4.4.3 → 4.6.0

package/lib/dash/dash_parser.js

@@ -19,6 +19,7 @@ goog.require('shaka.media.PresentationTimeline');
 goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.text.TextEngine');
+goog.require('shaka.util.ContentSteeringManager');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.Functional');
 goog.require('shaka.util.LanguageUtils');
@@ -115,6 +116,9 @@ shaka.dash.DashParser = class {
 
     /** @private {boolean} */
     this.lowLatencyMode_ = false;
+
+    /** @private {?shaka.util.ContentSteeringManager} */
+    this.contentSteeringManager_ = null;
   }
 
   /**
@@ -126,6 +130,10 @@ shaka.dash.DashParser = class {
         'DashManifestConfiguration should not be null!');
 
     this.config_ = config;
+
+    if (this.contentSteeringManager_) {
+      this.contentSteeringManager_.configure(this.config_);
+    }
   }
 
   /**
@@ -185,6 +193,10 @@ shaka.dash.DashParser = class {
       this.updateTimer_ = null;
     }
 
+    if (this.contentSteeringManager_) {
+      this.contentSteeringManager_.destroy();
+    }
+
     return this.operationManager_.destroy();
   }
 
@@ -212,6 +224,43 @@ shaka.dash.DashParser = class {
     // No-op
   }
 
+  /**
+   * @override
+   * @exportInterface
+   */
+  onInitialVariantChosen(variant) {
+    // For live it is necessary that the first time we update the manifest with
+    // a shorter time than indicated to take into account that the last segment
+    // added could be halfway, for example
+    if (this.manifest_ && this.manifest_.presentationTimeline.isLive()) {
+      const stream = variant.video || variant.audio;
+      if (stream && stream.segmentIndex) {
+        const availabilityEnd =
+            this.manifest_.presentationTimeline.getSegmentAvailabilityEnd();
+        const position = stream.segmentIndex.find(availabilityEnd);
+        if (position == null) {
+          return;
+        }
+        const reference = stream.segmentIndex.get(position);
+        if (!reference) {
+          return;
+        }
+        this.updatePeriod_ = reference.endTime - availabilityEnd;
+        this.setUpdateTimer_(/* offset= */ 0);
+      }
+    }
+  }
+
+  /**
+   * @override
+   * @exportInterface
+   */
+  banLocation(uri) {
+    if (this.contentSteeringManager_) {
+      this.contentSteeringManager_.banLocation(uri);
+    }
+  }
+
   /**
    * Makes a network request for the manifest and parses the resulting data.
    *
@@ -224,12 +273,10 @@ shaka.dash.DashParser = class {
     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MPD;
     const request = shaka.net.NetworkingEngine.makeRequest(
         this.manifestUris_, this.config_.retryParameters);
-    const networkingEngine = this.playerInterface_.networkingEngine;
     const startTime = Date.now();
-    const operation = networkingEngine.request(requestType, request, {type});
-    this.operationManager_.manage(operation);
 
-    const response = await operation.promise;
+    const response = await this.makeNetworkRequest_(
+        request, requestType, {type});
 
     // Detect calls to stop().
     if (!this.playerInterface_) {
@@ -322,10 +369,68 @@ shaka.dash.DashParser = class {
       manifestBaseUris = absoluteLocations;
     }
 
+    let contentSteeringPromise = Promise.resolve();
+
+    const contentSteering = XmlUtils.findChild(mpd, 'ContentSteering');
+    if (contentSteering && this.playerInterface_) {
+      const hasPrevContentSteeringManager = !!this.contentSteeringManager_;
+      if (!this.contentSteeringManager_) {
+        this.contentSteeringManager_ =
+            new shaka.util.ContentSteeringManager(this.playerInterface_);
+      }
+      this.contentSteeringManager_.configure(this.config_);
+      this.contentSteeringManager_.setBaseUris(manifestBaseUris);
+      this.contentSteeringManager_.setManifestType(
+          shaka.media.ManifestParser.DASH);
+      const defaultPathwayId =
+          contentSteering.getAttribute('defaultServiceLocation');
+      this.contentSteeringManager_.setDefaultPathwayId(defaultPathwayId);
+      if (!hasPrevContentSteeringManager) {
+        const uri = XmlUtils.getContents(contentSteering);
+        if (uri) {
+          const queryBeforeStart =
+            XmlUtils.parseAttr(contentSteering, 'queryBeforeStart',
+                XmlUtils.parseBoolean, /* defaultValue= */ false);
+          if (queryBeforeStart) {
+            contentSteeringPromise =
+                this.contentSteeringManager_.requestInfo(uri);
+          } else {
+            this.contentSteeringManager_.requestInfo(uri);
+          }
+        }
+      }
+    }
+
     const uriObjs = XmlUtils.findChildren(mpd, 'BaseURL');
-    const uris = uriObjs.map(XmlUtils.getContents);
-    const baseUris = shaka.util.ManifestParserUtils.resolveUris(
-        manifestBaseUris, uris);
+    let calculatedBaseUris;
+    let someLocationValid = false;
+    if (this.contentSteeringManager_) {
+      this.contentSteeringManager_.clearPreviousLocations();
+      for (const uriObj of uriObjs) {
+        const serviceLocation = uriObj.getAttribute('serviceLocation');
+        const uri = XmlUtils.getContents(uriObj);
+        if (serviceLocation && uri) {
+          this.contentSteeringManager_.addLocation(
+              'BaseURL', serviceLocation, uri);
+          someLocationValid = true;
+        }
+      }
+    }
+    if (!someLocationValid || !this.contentSteeringManager_) {
+      const uris = uriObjs.map(XmlUtils.getContents);
+      calculatedBaseUris = shaka.util.ManifestParserUtils.resolveUris(
+          manifestBaseUris, uris);
+    }
+
+    const getBaseUris = () => {
+      if (this.contentSteeringManager_ && someLocationValid) {
+        return this.contentSteeringManager_.getLocations('BaseURL');
+      }
+      if (calculatedBaseUris) {
+        return calculatedBaseUris;
+      }
+      return [];
+    };
 
     let availabilityTimeOffset = 0;
     if (uriObjs && uriObjs.length) {
@@ -441,7 +546,7 @@ shaka.dash.DashParser = class {
       profiles: profiles.split(','),
     };
 
-    const periodsAndDuration = this.parsePeriods_(context, baseUris, mpd);
+    const periodsAndDuration = this.parsePeriods_(context, getBaseUris, mpd);
     const duration = periodsAndDuration.duration;
     const periods = periodsAndDuration.periods;
 
@@ -485,18 +590,14 @@ shaka.dash.DashParser = class {
 
     await this.periodCombiner_.combinePeriods(periods, context.dynamic);
 
+    await contentSteeringPromise;
+
     // Set minBufferTime to 0 for low-latency DASH live stream to achieve the
     // best latency
     if (this.lowLatencyMode_) {
       minBufferTime = 0;
     }
 
-    // Set updatePeriod_ to minTotalAvailabilityTimeOffset_ to achieve the best
-    // latency in LL streams
-    if (this.lowLatencyMode_ && this.minTotalAvailabilityTimeOffset_) {
-      this.updatePeriod_ = this.minTotalAvailabilityTimeOffset_;
-    }
-
     // These steps are not done on manifest update.
     if (!this.manifest_) {
       this.manifest_ = {
@@ -517,7 +618,7 @@ shaka.dash.DashParser = class {
       if (presentationTimeline.usingPresentationStartTime()) {
         const XmlUtils = shaka.util.XmlUtils;
         const timingElements = XmlUtils.findChildren(mpd, 'UTCTiming');
-        const offset = await this.parseUtcTiming_(baseUris, timingElements);
+        const offset = await this.parseUtcTiming_(getBaseUris, timingElements);
         // Detect calls to stop().
         if (!this.playerInterface_) {
           return;
@@ -577,8 +678,19 @@ shaka.dash.DashParser = class {
       const maxPlaybackRate = playbackRateNode ?
         parseFloat(playbackRateNode.getAttribute('max')) :
         null;
+      const minLatency = latencyNode && latencyNode.getAttribute('min') ?
+        parseInt(latencyNode.getAttribute('min'), 10) / 1000 :
+        null;
+      const minPlaybackRate = playbackRateNode ?
+        parseFloat(playbackRateNode.getAttribute('min')) :
+        null;
 
-      return {maxLatency, maxPlaybackRate};
+      return {
+        maxLatency,
+        maxPlaybackRate,
+        minLatency,
+        minPlaybackRate,
+      };
     }
 
     return null;
@@ -590,7 +702,7 @@ shaka.dash.DashParser = class {
    * children.
    *
    * @param {shaka.dash.DashParser.Context} context
-   * @param {!Array.<string>} baseUris
+   * @param {function():!Array.<string>} getBaseUris
    * @param {!Element} mpd
    * @return {{
    *   periods: !Array.<shaka.extern.Period>,
@@ -599,7 +711,7 @@ shaka.dash.DashParser = class {
    * }}
    * @private
    */
-  parsePeriods_(context, baseUris, mpd) {
+  parsePeriods_(context, getBaseUris, mpd) {
     const XmlUtils = shaka.util.XmlUtils;
     const presentationDuration = XmlUtils.parseAttr(
         mpd, 'mediaPresentationDuration', XmlUtils.parseDuration);
@@ -689,7 +801,7 @@ shaka.dash.DashParser = class {
         node: elem,
         isLastPeriod: periodDuration == null || !next,
       };
-      const period = this.parsePeriod_(context, baseUris, info);
+      const period = this.parsePeriod_(context, getBaseUris, info);
       periods.push(period);
 
       if (context.period.id && periodDuration) {
@@ -743,17 +855,17 @@ shaka.dash.DashParser = class {
    * was done before this was called so start and duration are valid.
    *
    * @param {shaka.dash.DashParser.Context} context
-   * @param {!Array.<string>} baseUris
+   * @param {function():!Array.<string>} getBaseUris
    * @param {shaka.dash.DashParser.PeriodInfo} periodInfo
    * @return {shaka.extern.Period}
    * @private
    */
-  parsePeriod_(context, baseUris, periodInfo) {
+  parsePeriod_(context, getBaseUris, periodInfo) {
     const Functional = shaka.util.Functional;
     const XmlUtils = shaka.util.XmlUtils;
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    context.period = this.createFrame_(periodInfo.node, null, baseUris);
+    context.period = this.createFrame_(periodInfo.node, null, getBaseUris);
     context.periodInfo = periodInfo;
     context.period.availabilityTimeOffset = context.availabilityTimeOffset;
 
@@ -824,40 +936,29 @@ shaka.dash.DashParser = class {
       }
     }
 
-    const audioSets = this.config_.disableAudio ? [] :
-        this.getSetsOfType_(normalAdaptationSets, ContentType.AUDIO);
-    const videoSets = this.config_.disableVideo ? [] :
-        this.getSetsOfType_(normalAdaptationSets, ContentType.VIDEO);
-    const textSets = this.config_.disableText ? [] :
-        this.getSetsOfType_(normalAdaptationSets, ContentType.TEXT);
-    const imageSets = this.config_.disableThumbnails ? [] :
-        this.getSetsOfType_(normalAdaptationSets, ContentType.IMAGE);
-
-    if (!videoSets.length && !audioSets.length) {
+    const audioStreams = this.getStreamsFromSets_(
+        this.config_.disableAudio,
+        normalAdaptationSets,
+        ContentType.AUDIO);
+    const videoStreams = this.getStreamsFromSets_(
+        this.config_.disableVideo,
+        normalAdaptationSets,
+        ContentType.VIDEO);
+    const textStreams = this.getStreamsFromSets_(
+        this.config_.disableText,
+        normalAdaptationSets,
+        ContentType.TEXT);
+    const imageStreams = this.getStreamsFromSets_(
+        this.config_.disableThumbnails,
+        normalAdaptationSets,
+        ContentType.IMAGE);
+
+    if (videoStreams.length === 0 && audioStreams.length === 0) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.DASH_EMPTY_PERIOD);
-    }
-
-    const audioStreams = [];
-    for (const audioSet of audioSets) {
-      audioStreams.push(...audioSet.streams);
-    }
-
-    const videoStreams = [];
-    for (const videoSet of videoSets) {
-      videoStreams.push(...videoSet.streams);
-    }
-
-    const textStreams = [];
-    for (const textSet of textSets) {
-      textStreams.push(...textSet.streams);
-    }
-
-    const imageStreams = [];
-    for (const imageSet of imageSets) {
-      imageStreams.push(...imageSet.streams);
+          shaka.util.Error.Code.DASH_EMPTY_PERIOD,
+      );
     }
 
     return {
@@ -870,15 +971,26 @@ shaka.dash.DashParser = class {
   }
 
   /**
+   * Gets the streams from the given sets or returns an empty array if disabled
+   * or no streams are found.
+   * @param {boolean} disabled
    * @param {!Array.<!shaka.dash.DashParser.AdaptationInfo>} adaptationSets
-   * @param {string} type
-   * @return {!Array.<!shaka.dash.DashParser.AdaptationInfo>}
-   * @private
-   */
-  getSetsOfType_(adaptationSets, type) {
-    return adaptationSets.filter((as) => {
-      return as.contentType == type;
-    });
+   * @param {string} contentType
+   @private
+  */
+  getStreamsFromSets_(disabled, adaptationSets, contentType) {
+    if (disabled || !adaptationSets.length) {
+      return [];
+    }
+
+    return adaptationSets.reduce((all, part) => {
+      if (part.contentType != contentType) {
+        return all;
+      }
+
+      all.push(...part.streams);
+      return all;
+    }, []);
   }
 
   /**
@@ -966,6 +1078,7 @@ shaka.dash.DashParser = class {
         XmlUtils.findChildren(elem, 'EssentialProperty');
     // ID of real AdaptationSet if this is a trick mode set:
     let trickModeFor = null;
+    let isFastSwitching = false;
     let unrecognizedEssentialProperty = false;
     for (const prop of essentialProperties) {
       const schemeId = prop.getAttribute('schemeIdUri');
@@ -978,6 +1091,8 @@ shaka.dash.DashParser = class {
       } else if (schemeId == colourPrimariesScheme ||
                  schemeId == matrixCoefficientsScheme) {
         continue;
+      } else if (schemeId == 'urn:mpeg:dash:ssr:2023') {
+        isFastSwitching = true;
       } else {
         unrecognizedEssentialProperty = true;
       }
@@ -1135,6 +1250,7 @@ shaka.dash.DashParser = class {
           closedCaptions, representation, accessibilityPurpose);
       if (parsedRepresentation) {
         parsedRepresentation.hdr = parsedRepresentation.hdr || videoRange;
+        parsedRepresentation.fastSwitching = isFastSwitching;
       }
       return parsedRepresentation;
     }).filter((s) => !!s);
@@ -1169,6 +1285,9 @@ shaka.dash.DashParser = class {
       }
     }
 
+    const adaptationId = context.adaptationSet.id ||
+        ('__fake__' + this.globalId_++);
+
     for (const stream of streams) {
       // Some DRM license providers require that we have a default
       // key ID from the manifest in the wrapped license request.
@@ -1178,6 +1297,9 @@ shaka.dash.DashParser = class {
             new Set([...drmInfo.keyIds, ...stream.keyIds]) :
             drmInfo.keyIds || stream.keyIds;
       }
+      if (this.config_.dash.enableAudioGroups) {
+        stream.groupId = adaptationId;
+      }
     }
 
     const repIds = representations
@@ -1185,7 +1307,7 @@ shaka.dash.DashParser = class {
         .filter(shaka.util.Functional.isNotNull);
 
     return {
-      id: context.adaptationSet.id || ('__fake__' + this.globalId_++),
+      id: adaptationId,
       contentType: context.adaptationSet.contentType,
       language: language,
       main: main,
@@ -1250,29 +1372,69 @@ shaka.dash.DashParser = class {
     const isImage = contentType == ContentType.IMAGE;
 
     try {
+      /** @type {shaka.extern.aes128Key|undefined} */
+      let aes128Key = undefined;
+      if (contentProtection.aes128Info) {
+        const getBaseUris = context.representation.getBaseUris;
+        const uris = shaka.util.ManifestParserUtils.resolveUris(
+            getBaseUris(), [contentProtection.aes128Info.keyUri]);
+        const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
+        const request = shaka.net.NetworkingEngine.makeRequest(
+            uris, this.config_.retryParameters);
+
+        aes128Key = {
+          method: 'AES-128',
+          iv: contentProtection.aes128Info.iv,
+          firstMediaSequenceNumber: 0,
+        };
+
+        // Don't download the key object until the segment is parsed, to
+        // avoid a startup delay for long manifests with lots of keys.
+        aes128Key.fetchKey = async () => {
+          const keyResponse =
+              await this.makeNetworkRequest_(request, requestType);
+
+          // keyResponse.status is undefined when URI is
+          // "data:text/plain;base64,"
+          if (!keyResponse.data || keyResponse.data.byteLength != 16) {
+            throw new shaka.util.Error(
+                shaka.util.Error.Severity.CRITICAL,
+                shaka.util.Error.Category.MANIFEST,
+                shaka.util.Error.Code.AES_128_INVALID_KEY_LENGTH);
+          }
+
+          const algorithm = {
+            name: 'AES-CBC',
+          };
+          aes128Key.cryptoKey = await window.crypto.subtle.importKey(
+              'raw', keyResponse.data, algorithm, true, ['decrypt']);
+          aes128Key.fetchKey = undefined; // No longer needed.
+        };
+      }
       const requestSegment = (uris, startByte, endByte, isInit) => {
         return this.requestSegment_(uris, startByte, endByte, isInit);
       };
       if (context.representation.segmentBase) {
         streamInfo = shaka.dash.SegmentBase.createStreamInfo(
-            context, requestSegment);
+            context, requestSegment, aes128Key);
       } else if (context.representation.segmentList) {
         streamInfo = shaka.dash.SegmentList.createStreamInfo(
-            context, this.streamMap_);
+            context, this.streamMap_, aes128Key);
       } else if (context.representation.segmentTemplate) {
         const hasManifest = !!this.manifest_;
 
         streamInfo = shaka.dash.SegmentTemplate.createStreamInfo(
             context, requestSegment, this.streamMap_, hasManifest,
-            this.config_.dash.initialSegmentLimit, this.periodDurations_);
+            this.config_.dash.initialSegmentLimit, this.periodDurations_,
+            aes128Key);
       } else {
         goog.asserts.assert(isText,
             'Must have Segment* with non-text streams.');
 
-        const baseUris = context.representation.baseUris;
         const duration = context.periodInfo.duration || 0;
         streamInfo = {
           generateSegmentIndex: () => {
+            const baseUris = context.representation.getBaseUris();
             return Promise.resolve(shaka.media.SegmentIndex.forSingleSegment(
                 periodStart, duration, baseUris));
           },
@@ -1363,6 +1525,7 @@ shaka.dash.DashParser = class {
       stream = {
         id: this.globalId_++,
         originalId: context.representation.id,
+        groupId: null,
         createSegmentIndex: () => Promise.resolve(),
         closeSegmentIndex: () => {
           if (stream.segmentIndex) {
@@ -1397,10 +1560,12 @@ shaka.dash.DashParser = class {
         spatialAudio,
         closedCaptions,
         hdr,
+        videoLayout: undefined,
         tilesLayout,
         matchedStreams: [],
         accessibilityPurpose,
         external: false,
+        fastSwitching: false,
       };
     }
 
@@ -1456,6 +1621,8 @@ shaka.dash.DashParser = class {
       return;
     }
 
+    this.playerInterface_.onManifestUpdated();
+
     this.setUpdateTimer_(updateDelay);
   }
 
@@ -1471,8 +1638,8 @@ shaka.dash.DashParser = class {
     // NOTE: An updatePeriod_ of -1 means the attribute was missing.
     // An attribute which is present and set to 0 should still result in
     // periodic updates.  For more, see:
-    // https://github.com/shaka-project/shaka-player/issues/331
-    if (this.updatePeriod_ < 0) {
+    // https://github.com/Dash-Industry-Forum/Guidelines-TimingModel/issues/48
+    if (this.updatePeriod_ <= 0) {
       return;
     }
 
@@ -1490,13 +1657,13 @@ shaka.dash.DashParser = class {
    *
    * @param {!Element} elem
    * @param {?shaka.dash.DashParser.InheritanceFrame} parent
-   * @param {Array.<string>} baseUris
+   * @param {?function():!Array.<string>} getBaseUris
    * @return {shaka.dash.DashParser.InheritanceFrame}
    * @private
    */
-  createFrame_(elem, parent, baseUris) {
-    goog.asserts.assert(parent || baseUris,
-        'Must provide either parent or baseUris');
+  createFrame_(elem, parent, getBaseUris) {
+    goog.asserts.assert(parent || getBaseUris,
+        'Must provide either parent or getBaseUris');
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
     const XmlUtils = shaka.util.XmlUtils;
     parent = parent || /** @type {shaka.dash.DashParser.InheritanceFrame} */ ({
@@ -1509,14 +1676,44 @@ shaka.dash.DashParser = class {
       numChannels: null,
       audioSamplingRate: null,
       availabilityTimeOffset: 0,
+      segmentSequenceCadence: 0,
     });
-    baseUris = baseUris || parent.baseUris;
+    getBaseUris = getBaseUris || parent.getBaseUris;
 
     const parseNumber = XmlUtils.parseNonNegativeInt;
     const evalDivision = XmlUtils.evalDivision;
 
+    const id = elem.getAttribute('id');
     const uriObjs = XmlUtils.findChildren(elem, 'BaseURL');
-    const uris = uriObjs.map(XmlUtils.getContents);
+    let calculatedBaseUris;
+    let someLocationValid = false;
+    if (this.contentSteeringManager_) {
+      for (const uriObj of uriObjs) {
+        const serviceLocation = uriObj.getAttribute('serviceLocation');
+        const uri = XmlUtils.getContents(uriObj);
+        if (serviceLocation && uri) {
+          this.contentSteeringManager_.addLocation(
+              id, serviceLocation, uri);
+          someLocationValid = true;
+        }
+      }
+    }
+    if (!someLocationValid || !this.contentSteeringManager_) {
+      calculatedBaseUris = uriObjs.map(XmlUtils.getContents);
+    }
+
+    const getFrameUris = () => {
+      if (!uriObjs.length) {
+        return [];
+      }
+      if (this.contentSteeringManager_ && someLocationValid) {
+        return this.contentSteeringManager_.getLocations(id);
+      }
+      if (calculatedBaseUris) {
+        return calculatedBaseUris;
+      }
+      return [];
+    };
 
     let contentType = elem.getAttribute('contentType') || parent.contentType;
     const mimeType = elem.getAttribute('mimeType') || parent.mimeType;
@@ -1559,8 +1756,20 @@ shaka.dash.DashParser = class {
     const availabilityTimeOffset = parent.availabilityTimeOffset + baseUriAto +
         segmentBaseAto + segmentTemplateAto;
 
+    let segmentSequenceCadence = null;
+    const segmentSequenceProperties =
+        XmlUtils.findChild(elem, 'SegmentSequenceProperties');
+    if (segmentSequenceProperties) {
+      const sap = XmlUtils.findChild(segmentSequenceProperties, 'SAP');
+      if (sap) {
+        segmentSequenceCadence = XmlUtils.parseAttr(sap, 'cadence',
+            XmlUtils.parseInt);
+      }
+    }
+
     return {
-      baseUris: ManifestParserUtils.resolveUris(baseUris, uris),
+      getBaseUris:
+          () => ManifestParserUtils.resolveUris(getBaseUris(), getFrameUris()),
       segmentBase: segmentBase || parent.segmentBase,
       segmentList:
           XmlUtils.findChild(elem, 'SegmentList') || parent.segmentList,
@@ -1573,11 +1782,13 @@ shaka.dash.DashParser = class {
       frameRate: frameRate,
       pixelAspectRatio: pixelAspectRatio,
       emsgSchemeIdUris: emsgSchemeIdUris,
-      id: elem.getAttribute('id'),
+      id: id,
       language: elem.getAttribute('lang'),
       numChannels: numChannels,
       audioSamplingRate: audioSamplingRate,
       availabilityTimeOffset: availabilityTimeOffset,
+      segmentSequenceCadence:
+          segmentSequenceCadence || parent.segmentSequenceCadence,
     };
   }
 
@@ -1747,15 +1958,15 @@ shaka.dash.DashParser = class {
   /**
    * Makes a request to the given URI and calculates the clock offset.
    *
-   * @param {!Array.<string>} baseUris
+   * @param {function():!Array.<string>} getBaseUris
    * @param {string} uri
    * @param {string} method
    * @return {!Promise.<number>}
    * @private
    */
-  async requestForTiming_(baseUris, uri, method) {
+  async requestForTiming_(getBaseUris, uri, method) {
     const requestUris =
-        shaka.util.ManifestParserUtils.resolveUris(baseUris, [uri]);
+        shaka.util.ManifestParserUtils.resolveUris(getBaseUris(), [uri]);
     const request = shaka.net.NetworkingEngine.makeRequest(
         requestUris, this.config_.retryParameters);
     request.method = method;
@@ -1788,12 +1999,12 @@ shaka.dash.DashParser = class {
   /**
    * Parses an array of UTCTiming elements.
    *
-   * @param {!Array.<string>} baseUris
+   * @param {function():!Array.<string>} getBaseUris
    * @param {!Array.<!Element>} elems
    * @return {!Promise.<number>}
    * @private
    */
-  async parseUtcTiming_(baseUris, elems) {
+  async parseUtcTiming_(getBaseUris, elems) {
     const schemesAndValues = elems.map((elem) => {
       return {
         scheme: elem.getAttribute('schemeIdUri'),
@@ -1822,13 +2033,13 @@ shaka.dash.DashParser = class {
           case 'urn:mpeg:dash:utc:http-head:2014':
           case 'urn:mpeg:dash:utc:http-head:2012':
             // eslint-disable-next-line no-await-in-loop
-            return await this.requestForTiming_(baseUris, value, 'HEAD');
+            return await this.requestForTiming_(getBaseUris, value, 'HEAD');
           case 'urn:mpeg:dash:utc:http-xsdate:2014':
           case 'urn:mpeg:dash:utc:http-iso:2014':
           case 'urn:mpeg:dash:utc:http-xsdate:2012':
           case 'urn:mpeg:dash:utc:http-iso:2012':
             // eslint-disable-next-line no-await-in-loop
-            return await this.requestForTiming_(baseUris, value, 'GET');
+            return await this.requestForTiming_(getBaseUris, value, 'GET');
           case 'urn:mpeg:dash:utc:direct:2014':
           case 'urn:mpeg:dash:utc:direct:2012': {
             const date = Date.parse(value);
@@ -1929,10 +2140,8 @@ shaka.dash.DashParser = class {
         endByte,
         this.config_.retryParameters);
 
-    const networkingEngine = this.playerInterface_.networkingEngine;
-    const operation = networkingEngine.request(requestType, request, {type});
-    this.operationManager_.manage(operation);
-    const response = await operation.promise;
+    const response = await this.makeNetworkRequest_(
+        request, requestType, {type});
     return response.data;
   }
 
@@ -1958,6 +2167,24 @@ shaka.dash.DashParser = class {
     // types well.
     return mimeType.split('/')[0];
   }
+
+
+  /**
+   * Create a networking request. This will manage the request using the
+   * parser's operation manager.
+   *
+   * @param {shaka.extern.Request} request
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.RequestContext=} context
+   * @return {!Promise.<shaka.extern.Response>}
+   * @private
+   */
+  makeNetworkRequest_(request, type, context) {
+    const op = this.playerInterface_.networkingEngine.request(
+        type, request, context);
+    this.operationManager_.manage(op);
+    return op.promise;
+  }
 };
 
 
@@ -1975,7 +2202,7 @@ shaka.dash.DashParser.RequestSegmentCallback;
  *   segmentBase: Element,
  *   segmentList: Element,
  *   segmentTemplate: Element,
- *   baseUris: !Array.<string>,
+ *   getBaseUris: function():!Array.<string>,
  *   width: (number|undefined),
  *   height: (number|undefined),
  *   contentType: string,
@@ -1988,7 +2215,8 @@ shaka.dash.DashParser.RequestSegmentCallback;
  *   language: ?string,
  *   numChannels: ?number,
  *   audioSamplingRate: ?number,
- *   availabilityTimeOffset: number
+ *   availabilityTimeOffset: number,
+ *   segmentSequenceCadence: number
  * }}
  *
  * @description
@@ -2001,8 +2229,8 @@ shaka.dash.DashParser.RequestSegmentCallback;
  *   The XML node for SegmentList.
  * @property {Element} segmentTemplate
  *   The XML node for SegmentTemplate.
- * @property {!Array.<string>} baseUris
- *   An array of absolute base URIs for the frame.
+ * @property {function():!Array.<string>} getBaseUris
+ *   Function than returns an array of absolute base URIs for the frame.
  * @property {(number|undefined)} width
  *   The inherited width value.
  * @property {(number|undefined)} height
@@ -2029,6 +2257,9 @@ shaka.dash.DashParser.RequestSegmentCallback;
  *   Specifies the maximum sampling rate of the content, or null if unknown.
  * @property {number} availabilityTimeOffset
  *   Specifies the total availabilityTimeOffset of the segment, or 0 if unknown.
+ * @property {number} segmentSequenceCadence
+ *   Specifies the cadence of independent segments in Segment Sequence
+ *   Representation.
  */
 shaka.dash.DashParser.InheritanceFrame;
 
@@ -2162,8 +2393,6 @@ shaka.dash.DashParser.GenerateSegmentIndexFunction;
 shaka.dash.DashParser.StreamInfo;
 
 
-shaka.media.ManifestParser.registerParserByExtension(
-    'mpd', () => new shaka.dash.DashParser());
 shaka.media.ManifestParser.registerParserByMime(
     'application/dash+xml', () => new shaka.dash.DashParser());
 shaka.media.ManifestParser.registerParserByMime(