shaka-player 3.2.2 → 3.3.2

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.CmcdManager');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.Functional');
 goog.require('shaka.util.Iterables');
@@ -58,12 +59,12 @@ shaka.dash.DashParser = class {
     this.globalId_ = 1;
 
     /**
-     * A map of IDs to SegmentIndex objects.
+     * A map of IDs to Stream objects.
      * ID: Period@id,AdaptationSet@id,@Representation@id
      * e.g.: '1,5,23'
-     * @private {!Object.<string, !shaka.media.SegmentIndex>}
+     * @private {!Object.<string, !shaka.extern.Stream>}
      */
-    this.segmentIndexMap_ = {};
+    this.streamMap_ = {};
 
     /**
      * A map of period ids to their durations
@@ -164,8 +165,10 @@ shaka.dash.DashParser = class {
   stop() {
     // When the parser stops, release all segment indexes, which stops their
     // timers, as well.
-    for (const segmentIndex of Object.values(this.segmentIndexMap_)) {
-      segmentIndex.release();
+    for (const stream of Object.values(this.streamMap_)) {
+      if (stream.segmentIndex) {
+        stream.segmentIndex.release();
+      }
     }
 
     if (this.periodCombiner_) {
@@ -176,7 +179,7 @@ shaka.dash.DashParser = class {
     this.config_ = null;
     this.manifestUris_ = [];
     this.manifest_ = null;
-    this.segmentIndexMap_ = {};
+    this.streamMap_ = {};
     this.periodCombiner_ = null;
 
     if (this.updateTimer_ != null) {
@@ -224,6 +227,9 @@ shaka.dash.DashParser = class {
         this.manifestUris_, this.config_.retryParameters);
     const networkingEngine = this.playerInterface_.networkingEngine;
 
+    const format = shaka.util.CmcdManager.StreamingFormat.DASH;
+    this.playerInterface_.modifyManifestRequest(request, {format: format});
+
     const startTime = Date.now();
     const operation = networkingEngine.request(requestType, request);
     this.operationManager_.manage(operation);
@@ -378,8 +384,11 @@ shaka.dash.DashParser = class {
       // that the complex logic of multi-Period eviction and period-flattening
       // is correct.  See also:
       // https://github.com/google/shaka-player/issues/3169#issuecomment-823580634
-      for (const segmentIndex of Object.values(this.segmentIndexMap_)) {
-        segmentIndex.evict(presentationTimeline.getSegmentAvailabilityStart());
+      for (const stream of Object.values(this.streamMap_)) {
+        if (stream.segmentIndex) {
+          stream.segmentIndex.evict(
+              presentationTimeline.getSegmentAvailabilityStart());
+        }
       }
     } else {
       // DASH IOP v3.0 suggests using a default delay between minBufferTime
@@ -401,6 +410,24 @@ shaka.dash.DashParser = class {
           this.config_.dash.autoCorrectDrift);
     }
 
+    presentationTimeline.setStatic(mpdType == 'static');
+
+    const isLive = presentationTimeline.isLive();
+
+    // If it's live, we check for an override.
+    if (isLive && !isNaN(this.config_.availabilityWindowOverride)) {
+      segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
+    }
+
+    // If it's null, that means segments are always available.  This is always
+    // the case for VOD, and sometimes the case for live.
+    if (segmentAvailabilityDuration == null) {
+      segmentAvailabilityDuration = Infinity;
+    }
+
+    presentationTimeline.setSegmentAvailabilityDuration(
+        segmentAvailabilityDuration);
+
     const profiles = mpd.getAttribute('profiles') || '';
 
     /** @type {shaka.dash.DashParser.Context} */
@@ -423,7 +450,6 @@ shaka.dash.DashParser = class {
     const duration = periodsAndDuration.duration;
     const periods = periodsAndDuration.periods;
 
-    presentationTimeline.setStatic(mpdType == 'static');
     if (mpdType == 'static' ||
         !periodsAndDuration.durationDerivedFromPeriods) {
       // Ignore duration calculated from Period lengths if this is dynamic.
@@ -442,6 +468,7 @@ shaka.dash.DashParser = class {
         this.lowLatencyMode_ = this.playerInterface_.isLowLatencyMode();
       }
     }
+
     if (this.lowLatencyMode_) {
       presentationTimeline.setAvailabilityTimeOffset(
           this.minTotalAvailabilityTimeOffset_);
@@ -455,22 +482,6 @@ shaka.dash.DashParser = class {
         'https://bit.ly/3clctcj for details.');
     }
 
-    const isLive = presentationTimeline.isLive();
-
-    // If it's live, we check for an override.
-    if (isLive && !isNaN(this.config_.availabilityWindowOverride)) {
-      segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
-    }
-
-    // If it's null, that means segments are always available.  This is always
-    // the case for VOD, and sometimes the case for live.
-    if (segmentAvailabilityDuration == null) {
-      segmentAvailabilityDuration = Infinity;
-    }
-
-    presentationTimeline.setSegmentAvailabilityDuration(
-        segmentAvailabilityDuration);
-
     // Use @maxSegmentDuration to override smaller, derived values.
     presentationTimeline.notifyMaxSegmentDuration(maxSegmentDuration || 1);
     if (goog.DEBUG) {
@@ -705,8 +716,12 @@ shaka.dash.DashParser = class {
 
     const eventStreamNodes =
         XmlUtils.findChildren(periodInfo.node, 'EventStream');
+    const availabilityStart =
+        context.presentationTimeline.getSegmentAvailabilityStart();
+
     for (const node of eventStreamNodes) {
-      this.parseEventStream_(periodInfo.start, periodInfo.duration, node);
+      this.parseEventStream_(
+          periodInfo.start, periodInfo.duration, node, availabilityStart);
     }
 
     const adaptationSetNodes =
@@ -1163,11 +1178,12 @@ shaka.dash.DashParser = class {
             context, requestInitSegment);
       } else if (context.representation.segmentList) {
         streamInfo = shaka.dash.SegmentList.createStreamInfo(
-            context, this.segmentIndexMap_);
+            context, this.streamMap_);
       } else if (context.representation.segmentTemplate) {
         const hasManifest = !!this.manifest_;
+
         streamInfo = shaka.dash.SegmentTemplate.createStreamInfo(
-            context, requestInitSegment, this.segmentIndexMap_, hasManifest,
+            context, requestInitSegment, this.streamMap_, hasManifest,
             this.config_.dash.initialSegmentLimit, this.periodDurations_);
       } else {
         goog.asserts.assert(isText,
@@ -1220,8 +1236,10 @@ shaka.dash.DashParser = class {
 
     let forced = false;
     if (isText) {
-      // See: https://github.com/google/shaka-player/issues/2122
-      forced = roles.includes('forced_subtitle');
+      // See: https://github.com/google/shaka-player/issues/2122 and
+      // https://github.com/Dash-Industry-Forum/DASH-IF-IOP/issues/165
+      forced = roles.includes('forced_subtitle') ||
+          roles.includes('forced-subtitle');
     }
 
     let tilesLayout;
@@ -1254,13 +1272,29 @@ shaka.dash.DashParser = class {
       hdr = 'PQ';
     }
 
+    const contextId = context.representation.id ?
+        context.period.id + ',' + context.representation.id : '';
+
     /** @type {shaka.extern.Stream} */
     const stream = {
       id: this.globalId_++,
       originalId: context.representation.id,
       createSegmentIndex: async () => {
-        if (!stream.segmentIndex) {
-          stream.segmentIndex = await streamInfo.generateSegmentIndex();
+        // If we have a stream with the same context id stored in the map
+        // that has no segmentIndex, we should set the segmentIndex for it.
+        const storedInMap = contextId && context.dynamic &&
+              this.streamMap_[contextId];
+
+        const currentStream = storedInMap ? this.streamMap_[contextId] : stream;
+        if (!currentStream.segmentIndex) {
+          currentStream.segmentIndex = await streamInfo.generateSegmentIndex();
+        }
+      },
+
+      closeSegmentIndex: () => {
+        if (stream.segmentIndex) {
+          stream.segmentIndex.release();
+          stream.segmentIndex = null;
         }
       },
       segmentIndex: null,
@@ -1290,7 +1324,13 @@ shaka.dash.DashParser = class {
       closedCaptions,
       hdr,
       tilesLayout,
+      matchedStreams: [],
     };
+
+    if (contextId && context.dynamic && !this.streamMap_[contextId]) {
+      this.streamMap_[contextId] = stream;
+    }
+
     return stream;
   }
 
@@ -1735,9 +1775,10 @@ shaka.dash.DashParser = class {
    * @param {number} periodStart
    * @param {?number} periodDuration
    * @param {!Element} elem
+   * @param {number} availabilityStart
    * @private
    */
-  parseEventStream_(periodStart, periodDuration, elem) {
+  parseEventStream_(periodStart, periodDuration, elem, availabilityStart) {
     const XmlUtils = shaka.util.XmlUtils;
     const parseNumber = XmlUtils.parseNonNegativeInt;
 
@@ -1760,6 +1801,11 @@ shaka.dash.DashParser = class {
         endTime = Math.min(endTime, periodStart + periodDuration);
       }
 
+      // Don't add unavailable regions to the timeline.
+      if (endTime < availabilityStart) {
+        continue;
+      }
+
       /** @type {shaka.extern.TimelineRegionInfo} */
       const region = {
         schemeIdUri: schemeIdUri,

package/lib/dash/segment_base.js

@@ -61,7 +61,9 @@ shaka.dash.SegmentBase = class {
     }
 
     const getUris = () => resolvedUris;
-    return new shaka.media.InitSegmentReference(getUris, startByte, endByte);
+    const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
+    return new shaka.media.InitSegmentReference(
+        getUris, startByte, endByte, qualityInfo);
   }
 
   /**
@@ -346,4 +348,26 @@ shaka.dash.SegmentBase = class {
         indexRange.start, indexRange.end,
         scaledPresentationTimeOffset);
   }
+
+  /**
+   * Create a MediaQualityInfo object from a Context object.
+   *
+   * @param {!shaka.dash.DashParser.Context} context
+   * @return {!shaka.extern.MediaQualityInfo}
+   */
+  static createQualityInfo(context) {
+    const representation = context.representation;
+    return {
+      bandwidth: context.bandwidth,
+      audioSamplingRate: representation.audioSamplingRate,
+      codecs: representation.codecs,
+      contentType: representation.contentType,
+      frameRate: representation.frameRate || null,
+      height: representation.height || null,
+      mimeType: representation.mimeType,
+      channelsCount: representation.numChannels,
+      pixelAspectRatio: representation.pixelAspectRatio || null,
+      width: representation.width || null,
+    };
+  }
 };

package/lib/dash/segment_list.js

@@ -30,10 +30,10 @@ shaka.dash.SegmentList = class {
    * Updates the existing SegmentIndex, if any.
    *
    * @param {shaka.dash.DashParser.Context} context
-   * @param {!Object.<string, !shaka.media.SegmentIndex>} segmentIndexMap
+   * @param {!Object.<string, !shaka.extern.Stream>} streamMap
    * @return {shaka.dash.DashParser.StreamInfo}
    */
-  static createStreamInfo(context, segmentIndexMap) {
+  static createStreamInfo(context, streamMap) {
     goog.asserts.assert(context.representation.segmentList,
         'Should only be called with SegmentList');
     const SegmentList = shaka.dash.SegmentList;
@@ -46,11 +46,14 @@ shaka.dash.SegmentList = class {
 
     /** @type {shaka.media.SegmentIndex} */
     let segmentIndex = null;
-    let id = null;
+    let stream = null;
     if (context.period.id && context.representation.id) {
       // Only check/store the index if period and representation IDs are set.
-      id = context.period.id + ',' + context.representation.id;
-      segmentIndex = segmentIndexMap[id];
+      const id = context.period.id + ',' + context.representation.id;
+      stream = streamMap[id];
+      if (stream) {
+        segmentIndex = stream.segmentIndex;
+      }
     }
 
     const references = SegmentList.createSegmentReferences_(
@@ -64,9 +67,6 @@ shaka.dash.SegmentList = class {
       segmentIndex.mergeAndEvict(references, start);
     } else {
       segmentIndex = new shaka.media.SegmentIndex(references);
-      if (id && context.dynamic) {
-        segmentIndexMap[id] = segmentIndex;
-      }
     }
     context.presentationTimeline.notifySegments(references);
 
@@ -77,8 +77,17 @@ shaka.dash.SegmentList = class {
       segmentIndex.fit(periodStart, periodEnd, isNew);
     }
 
+    if (stream) {
+      stream.segmentIndex = segmentIndex;
+    }
+
     return {
-      generateSegmentIndex: () => Promise.resolve(segmentIndex),
+      generateSegmentIndex: () => {
+        if (!segmentIndex || segmentIndex.isEmpty()) {
+          segmentIndex.merge(references);
+        }
+        return Promise.resolve(segmentIndex);
+      },
     };
   }
 

package/lib/dash/segment_template.js

@@ -31,7 +31,7 @@ shaka.dash.SegmentTemplate = class {
    * @param {shaka.dash.DashParser.Context} context
    * @param {shaka.dash.DashParser.RequestInitSegmentCallback}
    *   requestInitSegment
-   * @param {!Object.<string, !shaka.media.SegmentIndex>} segmentIndexMap
+   * @param {!Object.<string, !shaka.extern.Stream>} streamMap
    * @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.
@@ -39,8 +39,8 @@ shaka.dash.SegmentTemplate = class {
    * @return {shaka.dash.DashParser.StreamInfo}
    */
   static createStreamInfo(
-      context, requestInitSegment, segmentIndexMap, isUpdate,
-      segmentLimit, periodDurationMap) {
+      context, requestInitSegment, streamMap, isUpdate, segmentLimit,
+      periodDurationMap) {
     goog.asserts.assert(context.representation.segmentTemplate,
         'Should only be called with SegmentTemplate');
     const SegmentTemplate = shaka.dash.SegmentTemplate;
@@ -86,10 +86,14 @@ shaka.dash.SegmentTemplate = class {
       /** @type {shaka.media.SegmentIndex} */
       let segmentIndex = null;
       let id = null;
+      let stream = null;
       if (context.period.id && context.representation.id) {
         // Only check/store the index if period and representation IDs are set.
         id = context.period.id + ',' + context.representation.id;
-        segmentIndex = segmentIndexMap[id];
+        stream = streamMap[id];
+        if (stream) {
+          segmentIndex = stream.segmentIndex;
+        }
       }
 
       const references = SegmentTemplate.createFromTimeline_(
@@ -117,9 +121,6 @@ shaka.dash.SegmentTemplate = class {
             context.presentationTimeline.getSegmentAvailabilityStart());
       } else {
         segmentIndex = new shaka.media.SegmentIndex(references);
-        if (id && context.dynamic) {
-          segmentIndexMap[id] = segmentIndex;
-        }
       }
       context.presentationTimeline.notifySegments(references);
 
@@ -127,8 +128,20 @@ shaka.dash.SegmentTemplate = class {
         segmentIndex.fit(periodStart, periodEnd);
       }
 
+      if (stream && context.dynamic) {
+        stream.segmentIndex = segmentIndex;
+      }
+
       return {
-        generateSegmentIndex: () => Promise.resolve(segmentIndex),
+        generateSegmentIndex: () => {
+          // If segmentIndex is deleted, or segmentIndex's references are
+          // released by closeSegmentIndex(), we should set the value of
+          // segmentIndex again.
+          if (!segmentIndex || segmentIndex.isEmpty()) {
+            segmentIndex.merge(references);
+          }
+          return Promise.resolve(segmentIndex);
+        },
       };
     }
   }
@@ -569,8 +582,8 @@ shaka.dash.SegmentTemplate = class {
           baseUris, [filledTemplate]);
       return resolvedUris;
     };
-
-    return new shaka.media.InitSegmentReference(getUris, 0, null);
+    const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
+    return new shaka.media.InitSegmentReference(getUris, 0, null, qualityInfo);
   }
 };