shaka-player 3.3.2 → 3.3.5

package/lib/hls/hls_parser.js

@@ -30,7 +30,6 @@ goog.require('shaka.util.DataViewReader');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.Functional');
-goog.require('shaka.util.Iterables');
 goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
@@ -919,7 +918,7 @@ shaka.hls.HlsParser = class {
       // the content. This means that if the content changes profiles, it should
       // include both. Since all known browsers support changing profiles
       // without any other work, just ignore them.  See also:
-      // https://github.com/google/shaka-player/issues/1817
+      // https://github.com/shaka-project/shaka-player/issues/1817
       const shortCodec = shaka.util.MimeUtils.getCodecBase(codec);
       if (!seen.has(shortCodec)) {
         ret.push(codec);
@@ -1740,8 +1739,8 @@ shaka.hls.HlsParser = class {
    * @param {number} timestampOffset
    * @param {!Map.<string, string>} variables
    * @param {string} absoluteMediaPlaylistUri
-   * @return {!shaka.media.SegmentReference}
    * @param {string} type
+   * @return {shaka.media.SegmentReference}
    * @private
    */
   createSegmentReference_(
@@ -1757,11 +1756,25 @@ shaka.hls.HlsParser = class {
     let startByte = 0;
     let endByte = null;
 
+    if (!extinfTag) {
+      if (hlsSegment.partialSegments.length == 0) {
+        // EXTINF tag must be available if the segment has no partial segments.
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MANIFEST,
+            shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, 'EXTINF');
+      } else if (!this.lowLatencyMode_) {
+        // Without EXTINF and without low-latency mode, partial segments get
+        // ignored.
+        return null;
+      }
+    }
+
     // Create SegmentReferences for the partial segments.
     const partialSegmentRefs = [];
-    if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
-      const enumerate = (it) => shaka.util.Iterables.enumerate(it);
-      for (const {i, item} of enumerate(hlsSegment.partialSegments)) {
+    if (this.lowLatencyMode_) {
+      for (let i = 0; i < hlsSegment.partialSegments.length; i++) {
+        const item = hlsSegment.partialSegments[i];
         const pPreviousReference = i == 0 ?
           previousReference : partialSegmentRefs[partialSegmentRefs.length - 1];
         const pStartTime = (i == 0) ? startTime : pPreviousReference.endTime;
@@ -1782,6 +1795,9 @@ shaka.hls.HlsParser = class {
             this.parseByteRange_(pPreviousReference, pByterange);
         }
         const pUri = item.getAttributeValue('URI');
+        if (!pUri) {
+          continue;
+        }
         const pAbsoluteUri = shaka.hls.Utils.constructAbsoluteUri(
             absoluteMediaPlaylistUri, pUri);
 
@@ -1797,14 +1813,6 @@ shaka.hls.HlsParser = class {
             /* appendWindowEnd= */ Infinity);
         partialSegmentRefs.push(partial);
       } // for-loop of hlsSegment.partialSegments
-    } else {
-      // EXTINF tag must be available if the segment has no partial segments.
-      if (!extinfTag) {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.MANIFEST,
-            shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, 'EXTINF');
-      }
     }
 
     // If the segment has EXTINF tag, set the segment's end time, start byte
@@ -1823,6 +1831,7 @@ shaka.hls.HlsParser = class {
     } else {
       endTime = partialSegmentRefs[partialSegmentRefs.length - 1].endTime;
     }
+
     // If the segment has EXT-X-BYTERANGE tag, set the start byte and end byte
     // base on the byterange information. If segment has no EXT-X-BYTERANGE tag
     // and has partial segments, set the start byte and end byte base on the
@@ -1989,9 +1998,9 @@ shaka.hls.HlsParser = class {
         // With delta updates, the DISCONTINUITY may be skipped. Check if
         // the discontintuity Sequence Number based on the media sequence
         // number.
-        while (discontinuityToMediaSequence.has(discontintuitySequenceNum + 1)
-            && discontinuityToMediaSequence.get(discontintuitySequenceNum + 1) <
-            position) {
+        const disconMap = discontinuityToMediaSequence;
+        while (disconMap.has(discontintuitySequenceNum + 1) &&
+            disconMap.get(discontintuitySequenceNum + 1) < position) {
           discontintuitySequenceNum++;
         }
       }
@@ -2002,8 +2011,8 @@ shaka.hls.HlsParser = class {
     /** @type {!Array.<!shaka.media.SegmentReference>} */
     const references = [];
 
-    const enumerate = (it) => shaka.util.Iterables.enumerate(it);
-    for (const {i, item} of enumerate(hlsSegments)) {
+    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;
@@ -2052,7 +2061,9 @@ shaka.hls.HlsParser = class {
             playlist.absoluteUri,
             type);
 
-        references.push(reference);
+        if (reference) {
+          references.push(reference);
+        }
       } else if (!this.lowLatencyMode_) {
         // If a segment has no extinfTag, it must contain partial segments.
         shaka.log.alwaysWarn('Low-latency HLS live stream detected, but ' +
@@ -2231,6 +2242,9 @@ shaka.hls.HlsParser = class {
         variables,
         /* absoluteMediaPlaylistUri= */ '',
         type);
+    goog.asserts.assert(
+        segmentRef != null, 'Segment reference should not be null!');
+
     // If we are updating the manifest, we can usually skip fetching the segment
     // by examining the references we already have.  This won't be possible if
     // there was some kind of lag or delay updating the manifest on the server,

package/lib/hls/manifest_text_parser.js

@@ -13,7 +13,6 @@ goog.require('shaka.hls.Segment');
 goog.require('shaka.hls.Tag');
 goog.require('shaka.hls.Utils');
 goog.require('shaka.util.Error');
-goog.require('shaka.util.Iterables');
 goog.require('shaka.util.StringUtils');
 goog.require('shaka.util.TextParser');
 
@@ -82,8 +81,9 @@ shaka.hls.ManifestTextParser = class {
     const tags = [];
     // Initialize to "true" to skip the first element.
     skip = true;
-    const enumerate = (it) => shaka.util.Iterables.enumerate(it);
-    for (const {i, item: line, next} of enumerate(lines)) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const next = lines[i + 1];
       // Skip comments
       if (shaka.hls.Utils.isComment(line) || skip) {
         skip = false;

package/lib/media/adaptation_set.js

@@ -8,7 +8,6 @@ goog.provide('shaka.media.AdaptationSet');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
-goog.require('shaka.util.Iterables');
 goog.require('shaka.util.MimeUtils');
 
 
@@ -215,7 +214,7 @@ shaka.media.AdaptationSet = class {
     codecsA.sort();
     codecsB.sort();
 
-    for (const i of shaka.util.Iterables.range(codecsA.length)) {
+    for (let i = 0; i < codecsA.length; i++) {
       if (codecsA[i] != codecsB[i]) {
         return false;
       }

package/lib/media/content_workarounds.js

@@ -31,7 +31,7 @@ shaka.media.ContentWorkarounds = class {
    *
    * @param {!BufferSource} initSegmentBuffer
    * @return {!Uint8Array}
-   * @see https://github.com/google/shaka-player/issues/2759
+   * @see https://github.com/shaka-project/shaka-player/issues/2759
    */
   static fakeEncryption(initSegmentBuffer) {
     const ContentWorkarounds = shaka.media.ContentWorkarounds;
@@ -283,7 +283,7 @@ shaka.media.ContentWorkarounds = class {
  *
  * @const {!shaka.util.Lazy.<!Uint8Array>}
  * @private
- * @see https://github.com/google/shaka-player/issues/2759
+ * @see https://github.com/shaka-project/shaka-player/issues/2759
  */
 shaka.media.ContentWorkarounds.CANNED_SINF_BOX_ =
     new shaka.util.Lazy(() => new Uint8Array([

package/lib/media/drm_engine.js

@@ -655,7 +655,7 @@ shaka.media.DrmEngine = class {
     // first MIME type even if the others are supported.  To work around this,
     // we say that Edge supports everything.
     //
-    // See https://github.com/google/shaka-player/issues/1495 for details.
+    // See https://github.com/shaka-project/shaka-player/issues/1495 for details.
     if (shaka.util.Platform.isLegacyEdge()) {
       return true;
     }
@@ -667,7 +667,8 @@ shaka.media.DrmEngine = class {
       // Some Tizen devices seem to misreport AC-3 support.  This works around
       // the issue, by falling back to EC-3, which seems to be supported on the
       // same devices and be correctly reported in all cases we have observed.
-      // See https://github.com/google/shaka-player/issues/2989 for details.
+      // See https://github.com/shaka-project/shaka-player/issues/2989 for
+      // details.
       const fallback = contentType.replace('ac-3', 'ec-3');
       return this.supportedTypes_.has(contentType) ||
              this.supportedTypes_.has(fallback);

package/lib/media/media_source_engine.js

@@ -63,6 +63,11 @@ shaka.media.MediaSourceEngine = class {
                            string>} */
     this.sourceBufferTypes_ = {};
 
+
+    /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
+                           boolean>} */
+    this.expectedEncryption_ = {};
+
     /** @private {shaka.text.TextEngine} */
     this.textEngine_ = null;
 
@@ -345,6 +350,7 @@ shaka.media.MediaSourceEngine = class {
         this.sourceBuffers_[contentType] = sourceBuffer;
         this.sourceBufferTypes_[contentType] = mimeType;
         this.queues_[contentType] = [];
+        this.expectedEncryption_[contentType] = !!stream.drmInfos.length;
       }
     }
   }
@@ -830,7 +836,8 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   setTimestampOffset_(contentType, timestampOffset) {
-    // Work around for https://github.com/google/shaka-player/issues/1281:
+    // Work around for
+    // https://github.com/shaka-project/shaka-player/issues/1281:
     // TODO(https://bit.ly/2ttKiBU): follow up when this is fixed in Edge
     if (timestampOffset < 0) {
       // Try to prevent rounding errors in Edge from removing the first
@@ -1090,7 +1097,7 @@ shaka.media.MediaSourceEngine = class {
    */
   workAroundBrokenPlatforms_(segment, startTime, contentType) {
     const isInitSegment = startTime == null;
-    const encryptionExpected = this.video_.mediaKeys;
+    const encryptionExpected = this.expectedEncryption_[contentType];
 
     // If:
     //   1. this is an init segment,
@@ -1100,7 +1107,7 @@ shaka.media.MediaSourceEngine = class {
     // then insert fake encryption metadata for init segments that lack it.
     // The MP4 requirement is because we can currently only do this
     // transformation on MP4 containers.
-    // See: https://github.com/google/shaka-player/issues/2759
+    // See: https://github.com/shaka-project/shaka-player/issues/2759
     if (isInitSegment &&
         encryptionExpected &&
         shaka.util.Platform.requiresEncryptionInfoInAllInitSegments() &&

package/lib/media/mp4_segment_index_parser.js

@@ -11,8 +11,6 @@ goog.require('shaka.log');
 goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.util.Error');
-goog.require('shaka.util.Functional');
-goog.require('shaka.util.Iterables');
 goog.require('shaka.util.Mp4Parser');
 
 
@@ -123,8 +121,7 @@ shaka.media.Mp4SegmentIndexParser = class {
     let unscaledStartTime = earliestPresentationTime;
     let startByte = sidxOffset + box.size + firstOffset;
 
-    for (const _ of shaka.util.Iterables.range(referenceCount)) {
-      shaka.util.Functional.ignored(_);
+    for (let i = 0; i < referenceCount; i++) {
       // |chunk| is 1 bit for |referenceType|, and 31 bits for |referenceSize|.
       const chunk = box.reader.readUint32();
       const referenceType = (chunk & 0x80000000) >>> 31;

package/lib/media/playhead.js

@@ -256,7 +256,7 @@ shaka.media.MediaSourcePlayhead = class {
     // We don't buffer when the livestream video is paused and the playhead time
     // is out of the seek range; thus, we do not clamp the current time when the
     // video is paused.
-    // https://github.com/google/shaka-player/issues/1121
+    // https://github.com/shaka-project/shaka-player/issues/1121
     if (this.mediaElement_.readyState > 0 && !this.mediaElement_.paused) {
       return this.clampTime_(time);
     }
@@ -362,7 +362,7 @@ shaka.media.MediaSourcePlayhead = class {
    * presentation duration.  Seeking to or starting at duration does not work
    * consistently across browsers.
    *
-   * @see https://github.com/google/shaka-player/issues/979
+   * @see https://github.com/shaka-project/shaka-player/issues/979
    * @param {number} time
    * @return {number} The adjusted seek time.
    * @private

package/lib/media/presentation_timeline.js

@@ -355,14 +355,23 @@ shaka.media.PresentationTimeline = class {
    * starting after this time should be assumed to be unavailable.
    *
    * @return {number} The current segment availability end time, in seconds,
-   *   relative to the start of the presentation.  Always returns the
-   *   presentation's duration for video-on-demand.
+   *   relative to the start of the presentation.  For VOD, the availability
+   *   end time is the content's duration.  If the Player's playRangeEnd
+   *   configuration is used, this can override the duration.
    * @export
    */
   getSegmentAvailabilityEnd() {
     if (!this.isLive() && !this.isInProgress()) {
       // It's a static manifest (can also be a dynamic->static conversion)
-      return this.maxSegmentEndTime_ || this.duration_;
+      if (this.maxSegmentEndTime_) {
+        // If we know segment times, use the min of that and duration.
+        // Note that the playRangeEnd configuration changes this.duration_.
+        // See https://github.com/shaka-project/shaka-player/issues/4026
+        return Math.min(this.maxSegmentEndTime_, this.duration_);
+      } else {
+        // If we don't have segment times, use duration.
+        return this.duration_;
+      }
     }
     // Can be either live or "in-progress recording" (live with known duration)
     return Math.min(this.getLiveEdge_() + this.availabilityTimeOffset_,
@@ -389,10 +398,11 @@ shaka.media.PresentationTimeline = class {
     // For VOD, the offset and end time are ignored, and we just return the
     // earliest segment time.  All segments are "safe" in VOD.  However, we
     // should round up to the nearest millisecond to avoid issues like
-    // https://github.com/google/shaka-player/issues/2831, in which we tried to
-    // seek repeatedly to catch up to the seek range, and never actually
-    // "arrived" within it.  The video's currentTime is not as accurate as the
-    // JS number representing the earliest segment time for some content.
+    // https://github.com/shaka-project/shaka-player/issues/2831, in which we
+    // tried to seek repeatedly to catch up to the seek range, and never
+    // actually "arrived" within it.  The video's currentTime is not as
+    // accurate as the JS number representing the earliest segment time for
+    // some content.
     if (this.segmentAvailabilityDuration_ == Infinity) {
       return Math.ceil(earliestSegmentTime * 1e3) / 1e3;
     }
@@ -407,7 +417,7 @@ shaka.media.PresentationTimeline = class {
     // Add the offset to the availability start to ensure that we don't fall
     // outside the availability window while we buffer; we don't need to add the
     // offset to earliestSegmentTime since that won't change over time.
-    // Also see: https://github.com/google/shaka-player/issues/692
+    // Also see: https://github.com/shaka-project/shaka-player/issues/692
     const desiredStart =
         Math.min(availabilityStart + offset, this.getSeekRangeEnd());
     return Math.max(earliestSegmentTime, desiredStart);

package/lib/media/streaming_engine.js

@@ -674,7 +674,7 @@ shaka.media.StreamingEngine = class {
 
     if (mediaState.waitingToClearBuffer) {
       // May not be performing an update, but an update will still happen.
-      // See: https://github.com/google/shaka-player/issues/334
+      // See: https://github.com/shaka-project/shaka-player/issues/334
       shaka.log.debug(logPrefix, 'clear: already waiting');
       return;
     }
@@ -920,9 +920,9 @@ shaka.media.StreamingEngine = class {
       // buffering forever at the end.
       // We should only do this if the duration needs to shrink.
       // Growing it by less than 1ms can actually cause buffering on
-      // replay, as in https://github.com/google/shaka-player/issues/979
+      // replay, as in https://github.com/shaka-project/shaka-player/issues/979
       // On some platforms, this can spuriously be 0, so ignore this case.
-      // https://github.com/google/shaka-player/issues/1967,
+      // https://github.com/shaka-project/shaka-player/issues/1967,
       const duration = this.playerInterface_.mediaSourceEngine.getDuration();
       if (duration != 0 &&
           duration < this.manifest_.presentationTimeline.getDuration()) {
@@ -1718,7 +1718,7 @@ shaka.media.StreamingEngine = class {
     const bufferedBehind = presentationTime - startTime;
 
     const overflow = bufferedBehind - bufferBehind;
-    // See: https://github.com/google/shaka-player/issues/2982
+    // See: https://github.com/shaka-project/shaka-player/issues/2982
     if (overflow <= 0.01) {
       shaka.log.v2(logPrefix,
           'buffer behind okay:',
@@ -2079,7 +2079,7 @@ shaka.media.StreamingEngine.MediaState_;
  * of the Period.
  *
  * NOTE: This was increased as part of the solution to
- * https://github.com/google/shaka-player/issues/1281
+ * https://github.com/shaka-project/shaka-player/issues/1281
  *
  * @const {number}
  * @private
@@ -2093,7 +2093,7 @@ shaka.media.StreamingEngine.APPEND_WINDOW_START_FUDGE_ = 0.1;
  * the Period.  This rounding error could then create an artificial gap and a
  * stutter when the gap-jumping logic takes over.
  *
- * https://github.com/google/shaka-player/issues/1597
+ * https://github.com/shaka-project/shaka-player/issues/1597
  *
  * @const {number}
  * @private

package/lib/media/time_ranges_utils.js

@@ -6,8 +6,6 @@
 
 goog.provide('shaka.media.TimeRangesUtils');
 
-goog.require('shaka.util.Iterables');
-
 
 /**
  * @summary A set of utility functions for dealing with TimeRanges objects.
@@ -157,7 +155,7 @@ shaka.media.TimeRangesUtils = class {
       return [];
     }
     const ret = [];
-    for (const i of shaka.util.Iterables.range(b.length)) {
+    for (let i = 0; i < b.length; i++) {
       ret.push({start: b.start(i), end: b.end(i)});
     }
     return ret;

package/lib/media/video_wrapper.js

@@ -141,7 +141,7 @@ shaka.media.VideoWrapper = class {
     // TODO: Need further investigation why it happens. Before and after
     // setting the current time, video.readyState is 1, video.paused is true,
     // and video.buffered's TimeRanges length is 0.
-    // See: https://github.com/google/shaka-player/issues/1298
+    // See: https://github.com/shaka-project/shaka-player/issues/1298
     this.mover_.moveTo(
         this.video_.currentTime == 0 ?
         startTime :

package/lib/net/networking_engine.js

@@ -431,7 +431,7 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     }
 
     // Schemes are meant to be case-insensitive.
-    // See https://github.com/google/shaka-player/issues/2173
+    // See https://github.com/shaka-project/shaka-player/issues/2173
     // and https://tools.ietf.org/html/rfc3986#section-3.1
     scheme = scheme.toLowerCase();
 

package/lib/offline/indexeddb/storage_mechanism.js

@@ -368,8 +368,10 @@ shaka.offline.indexeddb.StorageMechanism.SESSION_ID_STORE = 'session-ids';
 shaka.offline.StorageMuxer.register(
     'idb',
     () => {
-      // Offline storage is not supported on the Chromecast platform.
-      if (shaka.util.Platform.isChromecast()) {
+      // Offline storage is not supported on the Chromecast or Xbox One
+      // platforms.
+      if (shaka.util.Platform.isChromecast() ||
+          shaka.util.Platform.isXboxOne()) {
         return null;
       }
       // Offline storage requires the IndexedDB API.