shaka-player 3.0.11 → 3.0.15

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();
 
@@ -88,6 +94,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_ = [];
   }
 
   /**
@@ -468,6 +486,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);
 
@@ -501,6 +520,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,
@@ -511,6 +566,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
@@ -528,6 +587,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(
@@ -958,7 +1020,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()),
       ];
     };
 
@@ -378,7 +392,8 @@ shaka.dash.SegmentTemplate = class {
       const segmentStart = segmentPeriodTime + periodStart;
       // 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(segmentStart + segmentDuration,
+          getPeriodEnd());
 
       // This condition will be true unless the segmentStart was >= periodEnd.
       // If we've done the position calculations correctly, this won't happen.
@@ -394,7 +409,7 @@ shaka.dash.SegmentTemplate = class {
           initSegmentReference,
           timestampOffset,
           /* appendWindowStart= */ periodStart,
-          /* appendWindowEnd= */ periodEnd);
+          /* appendWindowEnd= */ getPeriodEnd());
     };
 
     for (let position = minPosition; position <= maxPosition; ++position) {
@@ -407,7 +422,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 +439,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 +451,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/hls/hls_parser.js

@@ -475,6 +475,30 @@ shaka.hls.HlsParser = class {
       }
     }
 
+    // Now that the content has been fit, notify segments.
+    this.segmentsToNotifyByStream_ = [];
+    const streamsToNotify = [];
+    for (const variant of variants) {
+      for (const stream of [variant.video, variant.audio]) {
+        if (stream) {
+          streamsToNotify.push(stream);
+        }
+      }
+    }
+    await Promise.all(streamsToNotify.map(async (stream) => {
+      await stream.createSegmentIndex();
+    }));
+    for (const stream of streamsToNotify) {
+      this.segmentsToNotifyByStream_.push(stream.segmentIndex.references);
+    }
+    this.notifySegments_();
+
+    // This asserts that the live edge is being calculated from segment times.
+    // For VOD and event streams, this check should still pass.
+    goog.asserts.assert(
+        !this.presentationTimeline_.usingPresentationStartTime(),
+        'We should not be using the presentation start time in HLS!');
+
     this.manifest_ = {
       presentationTimeline: this.presentationTimeline_,
       variants,
@@ -642,7 +666,8 @@ shaka.hls.HlsParser = class {
     // Create variants for each variant tag.
     const variantsPromises = tags.map(async (tag) => {
       const frameRate = tag.getAttributeValue('FRAME-RATE');
-      const bandwidth = Number(tag.getRequiredAttrValue('BANDWIDTH'));
+      const bandwidth = Number(tag.getAttributeValue('AVERAGE-BANDWIDTH')) ||
+        Number(tag.getRequiredAttrValue('BANDWIDTH'));
 
       const resolution = tag.getAttributeValue('RESOLUTION');
       const [width, height] = resolution ? resolution.split('x') : [null, null];
@@ -1063,7 +1088,7 @@ shaka.hls.HlsParser = class {
     // "AUTOSELECT=YES".  A value of "AUTOSELECT=NO" would imply that it may
     // only be selected explicitly by the user, and we don't have a way to
     // represent that in our model.
-    const defaultAttrValue = tag.getAttribute('DEFAULT');
+    const defaultAttrValue = tag.getAttributeValue('DEFAULT');
     const primary = defaultAttrValue == 'YES';
 
     const channelsCount = type == 'audio' ? this.getChannelsCount_(tag) : null;
@@ -1396,12 +1421,6 @@ shaka.hls.HlsParser = class {
     }
 
     this.notifySegments_();
-
-    // This asserts that the live edge is being calculated from segment times.
-    // For VOD and event streams, this check should still pass.
-    goog.asserts.assert(
-        !this.presentationTimeline_.usingPresentationStartTime(),
-        'We should not be using the presentation start time in HLS!');
   }
 
   /**
@@ -1637,9 +1656,6 @@ shaka.hls.HlsParser = class {
       references.push(reference);
     }
 
-    this.segmentsToNotifyByStream_.push(references);
-    this.notifySegments_();
-
     return references;
   }
 
@@ -1976,6 +1992,12 @@ shaka.hls.HlsParser = class {
       reader.rewind(1);
     };
 
+    // We will look a few packet-lengths forward to find the first sync byte.
+    // Note that we are using this method on what is already a subset of the
+    // file (the first |shaka.hls.HlsParser.START_OF_SEGMENT_SIZE_| bytes), so
+    // we can't look too far ahead to begin with.
+    let syncByteScanLength = Math.min(reader.getLength() - 188, 5 * 188);
+
     // TODO: refactor this while loop for better readability.
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -1984,8 +2006,16 @@ shaka.hls.HlsParser = class {
 
       syncByte = reader.readUint8();
       if (syncByte != 0x47) {
+        if (syncByteScanLength > 0) {
+          // This file could have started with a cut-off TS packet. Scan forward
+          // until we find a sync byte.
+          syncByteScanLength -= 1;
+          continue;
+        }
         fail();
       }
+      // If we've found a sync byte, stop scanning forward for future packets.
+      syncByteScanLength = 0;
 
       const flagsAndPacketId = reader.readUint16();
       const packetId = flagsAndPacketId & 0x1fff;

package/lib/media/content_workarounds.js

@@ -75,6 +75,24 @@ shaka.media.ContentWorkarounds = class {
             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
           });
         })
+        .fullBox('avc3', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
+          });
+        })
+        .fullBox('ac-3', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCA_,
+          });
+        })
+        .fullBox('ec-3', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCA_,
+          });
+        })
         .fullBox('mp4a', (box) => {
           boxesToModify.push({
             box,

package/lib/media/drm_engine.js

@@ -496,6 +496,7 @@ shaka.media.DrmEngine = class {
     tasks.push(session.remove());
 
     await Promise.all(tasks);
+    this.activeSessions_.delete(session);
   }
 
   /**
@@ -1750,9 +1751,16 @@ shaka.media.DrmEngine = class {
         // audio adaptations, so we shouldn't have to worry about checking
         // robustness.
         if (drm1.keySystem == drm2.keySystem) {
+          /** @type {Array<shaka.extern.InitDataOverride>} */
           let initData = [];
           initData = initData.concat(drm1.initData || []);
           initData = initData.concat(drm2.initData || []);
+          initData = initData.filter((d, i) => {
+            return d.keyId === undefined || i === initData.findIndex((d2) => {
+              return d2.keyId === d.keyId;
+            });
+          });
+
           const keyIds = drm1.keyIds && drm2.keyIds ?
               new Set([...drm1.keyIds, ...drm2.keyIds]) :
               drm1.keyIds || drm2.keyIds;

package/lib/media/gap_jumping_controller.js

@@ -154,8 +154,10 @@ shaka.media.GapJumpingController = class {
     }
     // Don't gap jump while paused, so that you don't constantly jump ahead
     // while paused on a livestream.  We make an exception for time 0, since we
-    // may be _required_ to seek on startup before play can begin.
-    if (this.video_.paused && this.video_.currentTime != 0) {
+    // may be _required_ to seek on startup before play can begin, but only if
+    // autoplay is enabled.
+    if (this.video_.paused && (this.video_.currentTime != 0 ||
+      (!this.video_.autoplay && this.video_.currentTime == 0))) {
       return;
     }
 
@@ -214,8 +216,10 @@ shaka.media.GapJumpingController = class {
       this.didFireLargeGap_ = true;
 
       // Event firing is synchronous.
-      const event = new shaka.util.FakeEvent(
-          'largegap', {'currentTime': currentTime, 'gapSize': jumpSize});
+      const data = new Map()
+          .set('currentTime', currentTime)
+          .set('gapSize', jumpSize);
+      const event = new shaka.util.FakeEvent('largegap', data);
       event.cancelable = true;
       this.onEvent_(event);
 

package/lib/media/media_source_engine.js

@@ -577,6 +577,13 @@ shaka.media.MediaSourceEngine = class {
     this.textEngine_.setSelectedClosedCaptionId(id, videoBufferEndTime);
   }
 
+  /** Disable embedded closed captions. */
+  clearSelectedClosedCaptionId() {
+    if (this.textEngine_) {
+      this.textEngine_.setSelectedClosedCaptionId('', 0);
+    }
+  }
+
   /**
    * Enqueue an operation to remove data from the SourceBuffer.
    *

package/lib/media/playhead.js

@@ -80,7 +80,7 @@ shaka.media.SrcEqualsPlayhead = class {
     // We listen for the loaded-data-event so that we know when we can
     // interact with |currentTime|.
     const onLoaded = () => {
-      if (this.startTime_ == null) {
+      if (this.startTime_ == null || this.startTime_ == 0) {
         this.started_ = true;
       } else {
         // Startup is complete only when the video element acknowledges the

package/lib/media/presentation_timeline.js

@@ -351,9 +351,10 @@ shaka.media.PresentationTimeline = class {
    */
   getSegmentAvailabilityEnd() {
     if (!this.isLive() && !this.isInProgress()) {
-      return this.duration_;
+      // It's a static manifest (can also be a dynamic->static conversion)
+      return this.maxSegmentEndTime_ || this.duration_;
     }
-
+    // Can be either live or "in-progress recording" (live with known duration)
     return Math.min(this.getLiveEdge_(), this.duration_);
   }
 

package/lib/media/segment_index.js

@@ -181,7 +181,9 @@ shaka.media.SegmentIndex = class {
 
   /**
    * Merges the given SegmentReferences.  Supports extending the original
-   * references only.  Will not replace old references or interleave new ones.
+   * references only.  Will replace old references with equivalent new ones, and
+   * keep any unique old ones.
+   *
    * Used, for example, by the DASH and HLS parser, where manifests may not list
    * all available references, so we must keep available references in memory to
    * fill the availability window.
@@ -189,6 +191,8 @@ shaka.media.SegmentIndex = class {
    * @param {!Array.<!shaka.media.SegmentReference>} references The list of
    *   SegmentReferences, which must be sorted first by their start times
    *   (ascending) and second by their end times (ascending).
+   * @deprecated Not used directly by our own parsers, so will become private in
+   *   v4.  Use mergeAndEvict() instead.
    * @export
    */
   merge(references) {
@@ -199,13 +203,13 @@ shaka.media.SegmentIndex = class {
       return;
     }
 
-    // Partial segments are used for live edge, and should be removed when they
-    // get older. Remove the old SegmentReferences after the first new
-    // reference's start time.
     if (!references.length) {
       return;
     }
 
+    // Partial segments are used for live edge, and should be removed when they
+    // get older. Remove the old SegmentReferences after the first new
+    // reference's start time.
     this.references = this.references.filter((r) => {
       return r.startTime < references[0].startTime;
     });
@@ -233,13 +237,27 @@ shaka.media.SegmentIndex = class {
    * @export
    */
   mergeAndEvict(references, windowStart) {
-    // FIlter out the references that are no longer available to avoid
+    // Filter out the references that are no longer available to avoid
     // repeatedly evicting them and messing up eviction count.
     references = references.filter((r) => {
-      return r.endTime > windowStart;
+      return r.endTime > windowStart &&
+          (this.references.length == 0 ||
+           r.endTime > this.references[0].startTime);
     });
 
+    const oldFirstRef = this.references[0];
     this.merge(references);
+    const newFirstRef = this.references[0];
+
+    if (oldFirstRef) {
+      // We don't compare the actual ref, since the object could legitimately be
+      // replaced with an equivalent.  Even the URIs could change due to
+      // load-balancing actions taken by the server.  However, if the time
+      // changes, its not an equivalent reference.
+      goog.asserts.assert(oldFirstRef.startTime == newFirstRef.startTime,
+          'SegmentIndex.merge should not change the first reference time!');
+    }
+
     this.evict(windowStart);
   }
 
@@ -363,20 +381,28 @@ shaka.media.SegmentIndex = class {
 
   /** @return {!shaka.media.SegmentIterator} */
   [Symbol.iterator]() {
-    return this.getIteratorForTime(0);
+    const iter = this.getIteratorForTime(0);
+    goog.asserts.assert(iter != null, 'Iterator for 0 should never be null!');
+    return iter;
   }
 
   /**
    * Returns a new iterator that initially points to the segment that contains
    * the given time.  Like the normal iterator, next() must be called first to
-   * get to the first element.
+   * get to the first element. Returns null if we do not find a segment at the
+   * requested time.
    *
    * @param {number} time
-   * @return {!shaka.media.SegmentIterator}
+   * @return {?shaka.media.SegmentIterator}
    * @export
    */
   getIteratorForTime(time) {
-    return new shaka.media.SegmentIterator(this, this.find(time) || 0);
+    const index = this.find(time);
+    if (index == null) {
+      return null;
+    } else {
+      return new shaka.media.SegmentIterator(this, index);
+    }
   }
 
 
@@ -463,7 +489,11 @@ shaka.media.SegmentIterator = class {
    */
   seek(time) {
     const iter = this.segmentIndex_.getIteratorForTime(time);
-    this.nextPosition_ = iter.nextPosition_;
+    if (iter) {
+      this.nextPosition_ = iter.nextPosition_;
+    } else {
+      this.nextPosition_ = Number.MAX_VALUE;
+    }
     return this.next().value;
   }