shaka-player 4.0.1 → 4.0.4

package/docs/tutorials/upgrade.md

@@ -25,6 +25,7 @@ application:
     - TextDecoder/TextEncoder platform support or polyfill required (affects
       Xbox One, but not evergreen browsers); we suggest the polyfill
       [https://github.com/anonyco/FastestSmallestTextEncoderDecoder](fastestsmallesttextencoderdecoder/EncoderDecoderTogether.min.js)
+      Fallback included by default in v4.2
 
   - Support removed:
     - IE11 support removed

package/docs/tutorials/welcome.md

@@ -98,11 +98,14 @@ You can find a full list of available browsers with `--browsers help`, and you
 can find a complete list of testing options with `--help`.
 
 
-#### Join the announcement list
+#### Announcements
 
-If you want to receive release or survey announcements, you should join our
+To subscribe to new releases on GitHub, you can follow
+[instructions from this blog](https://www.jessesquires.com/blog/2020/07/30/github-tip-watching-releases/).
+
+To receive infrequent announcements and surveys from us, you can join our
 [mailing list](https://groups.google.com/forum/#!forum/shaka-player-users).
-The list is very low volume.
+The list is very low volume, and can only be written to by us.
 
 
 #### Continue the Tutorials

package/externs/shaka/player.js

@@ -766,8 +766,10 @@ shaka.extern.DashManifestConfiguration;
  *   <i>Defaults to <code>'avc1.42E01E'</code>.</i>
  * @property {boolean} ignoreManifestProgramDateTime
  *   If <code>true</code>, the HLS parser will ignore the
- *   <code>EXT-X-PROGRAM-DATE-TIME</code> tags in the manifest.
- *   Meant for tags that are incorrect or malformed.
+ *   <code>EXT-X-PROGRAM-DATE-TIME</code> tags in the manifest and use media
+ *   sequence numbers instead.
+ *   Meant for streams where <code>EXT-X-PROGRAM-DATE-TIME</code> is incorrect
+ *   or malformed.
  *   <i>Defaults to <code>false</code>.</i>
  * @property {string} mediaPlaylistFullMimeType
  *   A string containing a full mime type, including both the basic mime type

package/lib/abr/simple_abr_manager.js

@@ -219,8 +219,9 @@ shaka.abr.SimpleAbrManager = class {
    * @export
    */
   getBandwidthEstimate() {
+    const defaultBandwidthEstimate = this.getDefaultBandwidth_();
     return this.bandwidthEstimator_.getBandwidthEstimate(
-        this.config_.defaultBandwidthEstimate);
+        defaultBandwidthEstimate);
   }
 
 

package/lib/dash/dash_parser.js

@@ -513,6 +513,11 @@ shaka.dash.DashParser = class {
         }
         presentationTimeline.setClockOffset(offset);
       }
+
+      // This is the first point where we have a meaningful presentation start
+      // time, and we need to tell PresentationTimeline that so that it can
+      // maintain consistency from here on.
+      presentationTimeline.lockStartTime();
     } else {
       // Just update the variants and text streams, which may change as periods
       // are added or removed.

package/lib/hls/hls_parser.js

@@ -121,13 +121,19 @@ shaka.hls.HlsParser = class {
     this.updatePlaylistDelay_ = 0;
 
     /**
-     * A time offset to apply to EXT-X-PROGRAM-DATE-TIME values to normalize
-     * them so that they start at 0. This is necessary because these times will
-     * be used to set presentation times for segments.
-     * null means we don't have enough data yet.
+     * If true, we have already calculated offsets to synchronize streams.
+     * Offsets are computed in syncStreams*_().
+     * @private {boolean}
+     */
+    this.streamsSynced_ = false;
+
+    /**
+     * The minimum sequence number for generated segments, when ignoring
+     * EXT-X-PROGRAM-DATE-TIME.
+     *
      * @private {?number}
      */
-    this.syncTimeOffset_ = null;
+    this.minSequenceNumber_ = null;
 
     /**
      * This timer is used to trigger the start of a manifest update. A manifest
@@ -361,39 +367,155 @@ shaka.hls.HlsParser = class {
   }
 
   /**
-   * If necessary, makes sure that sync times will be normalized to 0, so that
-   * a stream does not start buffering at 50 years in because sync times are
-   * measured in time since 1970.
+   * Align all streams by sequence number by dropping early segments.  Then
+   * offset all streams to begin at presentation time 0.
    * @private
    */
-  calculateSyncTimeOffset_() {
-    if (this.syncTimeOffset_ != null) {
-      // The offset was already calculated.
+  syncStreamsWithSequenceNumber_() {
+    if (this.streamsSynced_) {
       return;
     }
 
-    const segments = new Set();
-    let lowestSyncTime = Infinity;
+    // Sync using media sequence number.  Find the highest starting sequence
+    // number among all streams.  Later, we will drop any references to
+    // earlier segments in other streams, then offset everything back to 0.
+    let highestStartingSequenceNumber = -1;
+    const firstSequenceNumberMap = new Map();
+
     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
       const segmentIndex = streamInfo.stream.segmentIndex;
       if (segmentIndex) {
-        segmentIndex.forEachTopLevelReference((segment) => {
-          if (segment.syncTime != null) {
-            lowestSyncTime = Math.min(lowestSyncTime, segment.syncTime);
-            segments.add(segment);
+        const segment0 = segmentIndex.earliestReference();
+        if (segment0) {
+          // This looks inefficient, but iteration order is insertion order.
+          // So the very first entry should be the one we want.
+          // We assert that this holds true so that we are alerted by debug
+          // builds and tests if it changes.  We still do a loop, though, so
+          // that the code functions correctly in production no matter what.
+          if (goog.DEBUG) {
+            const firstSequenceStartTime =
+                streamInfo.mediaSequenceToStartTime.values().next().value;
+            goog.asserts.assert(
+                firstSequenceStartTime == segment0.startTime,
+                'Sequence number map is not ordered as expected!');
           }
-        });
+          for (const [sequence, start] of streamInfo.mediaSequenceToStartTime) {
+            if (start == segment0.startTime) {
+              firstSequenceNumberMap.set(streamInfo, sequence);
+
+              highestStartingSequenceNumber = Math.max(
+                  highestStartingSequenceNumber, sequence);
+              break;
+            }
+          }
+        }
       }
     }
-    if (segments.size > 0) {
-      this.syncTimeOffset_ = -lowestSyncTime;
-      for (const segment of segments) {
-        segment.syncTime += this.syncTimeOffset_;
-        for (const partial of segment.partialReferences) {
-          partial.syncTime += this.syncTimeOffset_;
+
+    if (highestStartingSequenceNumber < 0) {
+      // Nothing to sync.
+      return;
+    }
+
+    // From now on, updates will ignore any references before this number.
+    this.minSequenceNumber_ = highestStartingSequenceNumber;
+
+    shaka.log.debug('Syncing HLS streams against base sequence number:',
+        this.minSequenceNumber_);
+
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      const segmentIndex = streamInfo.stream.segmentIndex;
+      if (segmentIndex) {
+        // Drop any earlier references.
+        const numSegmentsToDrop = this.minSequenceNumber_ -
+            firstSequenceNumberMap.get(streamInfo);
+        segmentIndex.dropFirstReferences(numSegmentsToDrop);
+
+        // Now adjust timestamps back to begin at 0.
+        const segmentN = segmentIndex.earliestReference();
+        if (segmentN) {
+          this.offsetStream_(streamInfo, -segmentN.startTime);
         }
       }
     }
+
+    this.streamsSynced_ = true;
+  }
+
+  /**
+   * Synchronize streams by the EXT-X-PROGRAM-DATE-TIME tags attached to their
+   * segments.  Also normalizes segment times so that the earliest segment in
+   * any stream is at time 0.
+   * @private
+   */
+  syncStreamsWithProgramDateTime_() {
+    if (this.streamsSynced_) {
+      return;
+    }
+
+    let lowestSyncTime = Infinity;
+
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      const segmentIndex = streamInfo.stream.segmentIndex;
+      if (segmentIndex) {
+        const segment0 = segmentIndex.earliestReference();
+        if (segment0 != null && segment0.syncTime != null) {
+          lowestSyncTime = Math.min(lowestSyncTime, segment0.syncTime);
+        }
+      }
+    }
+
+    if (lowestSyncTime == Infinity) {
+      // Nothing to sync.
+      return;
+    }
+
+    shaka.log.debug('Syncing HLS streams against base time:', lowestSyncTime);
+
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      const segmentIndex = streamInfo.stream.segmentIndex;
+      if (segmentIndex != null) {
+        const segment0 = segmentIndex.earliestReference();
+        if (segment0.syncTime == null) {
+          shaka.log.alwaysError('Missing EXT-X-PROGRAM-DATE-TIME for stream',
+              streamInfo.verbatimMediaPlaylistUri,
+              'Expect AV sync issues!');
+        } else {
+          // The first segment's target startTime should be based entirely on
+          // its syncTime.  The rest of the stream will be based on that
+          // starting point.  The earliest segment sync time from any stream
+          // will become presentation time 0.  If two streams start e.g. 6
+          // seconds apart in syncTime, then their first segments will also
+          // start 6 seconds apart in presentation time.
+          const segment0TargetTime = segment0.syncTime - lowestSyncTime;
+          const streamOffset = segment0TargetTime - segment0.startTime;
+
+          this.offsetStream_(streamInfo, streamOffset);
+        }
+      }
+    }
+
+    this.streamsSynced_ = true;
+  }
+
+  /**
+   * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
+   * @param {number} offset
+   * @private
+   */
+  offsetStream_(streamInfo, offset) {
+    streamInfo.stream.segmentIndex.offset(offset);
+
+    streamInfo.maxTimestamp += offset;
+    goog.asserts.assert(streamInfo.maxTimestamp >= 0,
+        'Negative maxTimestamp after adjustment!');
+
+    for (const [key, value] of streamInfo.mediaSequenceToStartTime) {
+      streamInfo.mediaSequenceToStartTime.set(key, value + offset);
+    }
+
+    shaka.log.debug('Offset', offset, 'applied to',
+        streamInfo.verbatimMediaPlaylistUri);
   }
 
   /**
@@ -524,7 +646,11 @@ shaka.hls.HlsParser = class {
 
     // Now that we have generated all streams, we can determine the offset to
     // apply to sync times.
-    this.calculateSyncTimeOffset_();
+    if (this.config_.hls.ignoreManifestProgramDateTime) {
+      this.syncStreamsWithSequenceNumber_();
+    } else {
+      this.syncStreamsWithProgramDateTime_();
+    }
 
     if (this.aesEncrypted_ && variants.length == 0) {
       // We do not support AES-128 encryption with HLS yet. Variants is null
@@ -539,15 +665,12 @@ shaka.hls.HlsParser = class {
 
     // Find the min and max timestamp of the earliest segment in all streams.
     // Find the minimum duration of all streams as well.
-    let minFirstTimestamp = Infinity;
     let minDuration = Infinity;
-
     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
-      minFirstTimestamp =
-          Math.min(minFirstTimestamp, streamInfo.minTimestamp);
       if (streamInfo.stream.type != 'text') {
-        minDuration = Math.min(minDuration,
-            streamInfo.maxTimestamp - streamInfo.minTimestamp);
+        // Since everything is already offset to 0 (either by sync or by being
+        // VOD), only maxTimestamp is necessary to compute the duration.
+        minDuration = Math.min(minDuration, streamInfo.maxTimestamp);
       }
     }
 
@@ -591,18 +714,11 @@ shaka.hls.HlsParser = class {
             segmentAvailabilityDuration);
       }
     } else {
-      // For VOD/EVENT content, offset everything back to 0.
-      // Use the minimum timestamp as the offset for all streams.
       // Use the minimum duration as the presentation duration.
       this.presentationTimeline_.setDuration(minDuration);
-      // Use a negative offset to adjust towards 0.
-      this.presentationTimeline_.offset(-minFirstTimestamp);
 
       for (const streamInfo of this.uriToStreamInfosMap_.values()) {
-        // The segments were created with actual media times, rather than
-        // presentation-aligned times, so offset them all now.
-        streamInfo.stream.segmentIndex.offset(-minFirstTimestamp);
-        // Finally, fit the segments to the playlist duration.
+        // Fit the segments to the playlist duration.
         streamInfo.stream.segmentIndex.fit(/* periodStart= */ 0, minDuration);
       }
     }
@@ -623,8 +739,14 @@ shaka.hls.HlsParser = class {
     for (const stream of streamsToNotify) {
       this.segmentsToNotifyByStream_.push(stream.segmentIndex.references);
     }
+
     this.notifySegments_();
 
+    // This is the first point where we have a meaningful presentation start
+    // time, and we need to tell PresentationTimeline that so that it can
+    // maintain consistency from here on.
+    this.presentationTimeline_.lockStartTime();
+
     // 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(
@@ -810,12 +932,7 @@ shaka.hls.HlsParser = class {
     });
 
     // Create stream info for each audio / video media tag.
-    // Wait for the first stream info created, so that the start time is fetched
-    // and can be reused.
-    if (mediaTags.length) {
-      await this.createStreamInfoFromMediaTag_(mediaTags[0]);
-    }
-    const promises = mediaTags.slice(1).map((tag) => {
+    const promises = mediaTags.map((tag) => {
       return this.createStreamInfoFromMediaTag_(tag);
     });
     await Promise.all(promises);
@@ -1583,7 +1700,6 @@ shaka.hls.HlsParser = class {
       throw error;
     }
 
-    const minTimestamp = segments[0].startTime;
     const lastEndTime = segments[segments.length - 1].endTime;
     /** @type {!shaka.media.SegmentIndex} */
     const segmentIndex = new shaka.media.SegmentIndex(segments);
@@ -1641,7 +1757,6 @@ shaka.hls.HlsParser = class {
       stream,
       verbatimMediaPlaylistUri,
       absoluteMediaPlaylistUri,
-      minTimestamp,
       maxTimestamp: lastEndTime,
       mediaSequenceToStartTime,
       canSkipSegments,
@@ -1749,8 +1864,6 @@ shaka.hls.HlsParser = class {
       /* presentationStartTime= */ null, /* delay= */ 0);
       this.presentationTimeline_.setStatic(true);
     }
-
-    this.notifySegments_();
   }
 
   /**
@@ -1853,15 +1966,9 @@ shaka.hls.HlsParser = class {
       const dateTimeTag =
           shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-PROGRAM-DATE-TIME');
       if (dateTimeTag && dateTimeTag.value) {
-        const time = shaka.util.XmlUtils.parseDate(dateTimeTag.value);
-        goog.asserts.assert(time != null,
+        syncTime = shaka.util.XmlUtils.parseDate(dateTimeTag.value);
+        goog.asserts.assert(syncTime != null,
             'EXT-X-PROGRAM-DATE-TIME format not valid');
-        // Sync time offset is null on the first go-through. This indicates that
-        // we have not yet seen every stream, and thus do not yet have enough
-        // information to determine how to normalize the sync times.
-        // For that first go-through, the sync time will be applied after the
-        // references are all created. Until then, just offset by 0.
-        syncTime = time + (this.syncTimeOffset_ || 0);
       }
     }
 
@@ -1892,9 +1999,20 @@ shaka.hls.HlsParser = class {
         const pPreviousReference = i == 0 ?
           previousReference : partialSegmentRefs[partialSegmentRefs.length - 1];
         const pStartTime = (i == 0) ? startTime : pPreviousReference.endTime;
-        const pDuration = Number(item.getAttributeValue('DURATION'));
-        // A preload hinted partial segment doesn't have duration information,
-        // so its startTime and endTime are the same.
+
+        // If DURATION is missing from this partial segment, use the target
+        // partial duration from the top of the playlist, which is a required
+        // attribute for content with partial segments.
+        const pDuration = Number(item.getAttributeValue('DURATION')) ||
+            this.partialTargetDuration_;
+
+        // If for some reason we have neither an explicit duration, nor a target
+        // partial duration, we should SKIP this partial segment to avoid
+        // duplicating content in the presentation timeline.
+        if (!pDuration) {
+          continue;
+        }
+
         const pEndTime = pStartTime + pDuration;
 
         let pStartByte = 0;
@@ -2074,16 +2192,13 @@ shaka.hls.HlsParser = class {
       firstStartTime = mediaSequenceToStartTime.get(position);
     }
 
-    const firstSegmentUri = hlsSegments[0].absoluteUri;
-    shaka.log.debug('First segment', firstSegmentUri.split('/').pop(),
-        'starts at', firstStartTime);
-
     /** @type {!Array.<!shaka.media.SegmentReference>} */
     const references = [];
 
+    let previousReference = null;
+
     for (let i = 0; i < hlsSegments.length; i++) {
       const item = hlsSegments[i];
-      const previousReference = references[references.length - 1];
       const startTime =
           (i == 0) ? firstStartTime : previousReference.endTime;
       position = mediaSequenceNumber + skippedSegments + i;
@@ -2113,9 +2228,17 @@ shaka.hls.HlsParser = class {
           variables,
           playlist.absoluteUri,
           type);
+      previousReference = reference;
 
       if (reference) {
-        references.push(reference);
+        if (this.config_.hls.ignoreManifestProgramDateTime &&
+            this.minSequenceNumber_ != null &&
+            position < this.minSequenceNumber_) {
+          // This segment is ignored as part of our fallback synchronization
+          // method.
+        } else {
+          references.push(reference);
+        }
       }
     }
 
@@ -2245,12 +2368,16 @@ shaka.hls.HlsParser = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
+    // If you wait long enough, requesting the first segment can fail
+    // because it has fallen off the left edge of DVR, so to be safer,
+    // let's request the middle segment.
     goog.asserts.assert(playlist.segments.length,
         'Playlist should have segments!');
-    const firstSegmentUri = this.variableSubstitution_(
-        playlist.segments[0].absoluteUri, variables);
+    const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
+    const middleSegmentUri = this.variableSubstitution_(
+        playlist.segments[middleSegmentIdx].absoluteUri, variables);
 
-    const parsedUri = new goog.Uri(firstSegmentUri);
+    const parsedUri = new goog.Uri(middleSegmentUri);
     const extension = parsedUri.getPath().split('.').pop();
     const map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
 
@@ -2280,7 +2407,7 @@ shaka.hls.HlsParser = class {
     // If unable to guess mime type, request a segment and try getting it
     // from the response.
     const headRequest = shaka.net.NetworkingEngine.makeRequest(
-        [firstSegmentUri], this.config_.retryParameters);
+        [middleSegmentUri], this.config_.retryParameters);
     headRequest.method = 'HEAD';
 
     const response = await this.makeNetworkRequest_(
@@ -2567,7 +2694,6 @@ shaka.hls.HlsParser = class {
  *   stream: !shaka.extern.Stream,
  *   verbatimMediaPlaylistUri: string,
  *   absoluteMediaPlaylistUri: string,
- *   minTimestamp: number,
  *   maxTimestamp: number,
  *   mediaSequenceToStartTime: !Map.<number, number>,
  *   canSkipSegments: boolean
@@ -2586,8 +2712,6 @@ shaka.hls.HlsParser = class {
  * @property {string} absoluteMediaPlaylistUri
  *   The absolute media playlist URI, resolved relative to the master playlist
  *   and updated to reflect any redirects.
- * @property {number} minTimestamp
- *   The minimum timestamp found in the stream.
  * @property {number} maxTimestamp
  *   The maximum timestamp found in the stream.
  * @property {!Map.<number, number>} mediaSequenceToStartTime

package/lib/media/drm_engine.js

@@ -1424,6 +1424,9 @@ shaka.media.DrmEngine = class {
       }
       return;
     }
+    if (this.destroyer_.destroyed()) {
+      return;
+    }
 
     const updateEvent = new shaka.util.FakeEvent('drmsessionupdate');
     this.playerInterface_.onEvent(updateEvent);