shaka-player 3.2.1 → 3.3.1

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
@@ -95,6 +96,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.
@@ -152,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_) {
@@ -164,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) {
@@ -212,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);
@@ -366,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
@@ -538,6 +559,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);
 
@@ -571,6 +593,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,
@@ -602,6 +660,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(
@@ -813,6 +874,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:
@@ -822,11 +902,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();
@@ -952,8 +1047,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) {
@@ -1072,11 +1172,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,
@@ -1129,8 +1230,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;
@@ -1163,13 +1266,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,
@@ -1199,7 +1318,13 @@ shaka.dash.DashParser = class {
       closedCaptions,
       hdr,
       tilesLayout,
+      matchedStreams: [],
     };
+
+    if (contextId && context.dynamic && !this.streamMap_[contextId]) {
+      this.streamMap_[contextId] = stream;
+    }
+
     return stream;
   }
 

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_(
@@ -63,12 +66,9 @@ 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;
@@ -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_(
@@ -116,19 +120,28 @@ 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);
       }
 
+      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);
   }
 };