shaka-player 4.7.11 → 4.7.12

package/lib/polyfill/mediasource.js

@@ -30,14 +30,8 @@ shaka.polyfill.MediaSource = class {
     // platform detection tricks to decide which patches to install.
     const safariVersion = shaka.util.Platform.safariVersion();
 
-    if (!window.MediaSource) {
+    if (!window.MediaSource && !window.ManagedMediaSource) {
       shaka.log.info('No MSE implementation available.');
-    } else if (shaka.util.Platform.isChromecast()) {
-      shaka.log.info('Patching Chromecast MSE bugs.');
-      // Chromecast fails on some TS content, even though it is supposed to
-      // support it.  Better to transmux.
-      // See https://github.com/shaka-project/shaka-player/issues/5278
-      shaka.polyfill.MediaSource.rejectContainer_('mp2t');
     } else if (safariVersion) {
       // NOTE:  shaka.Player.isBrowserSupported() has its own restrictions on
       // Safari version.
@@ -73,11 +67,6 @@ shaka.polyfill.MediaSource = class {
         // Bug filed: https://bugs.webkit.org/show_bug.cgi?id=165342
         shaka.polyfill.MediaSource.stubAbort_();
       }
-    } else if (shaka.util.Platform.isEdge()) {
-      shaka.log.info('Rejecting TS container.');
-      // TS content is broken on Edge in general.
-      // See https://github.com/shaka-project/shaka-player/issues/4955
-      shaka.polyfill.MediaSource.rejectContainer_('mp2t');
     } else if (shaka.util.Platform.isTizen2() ||
         shaka.util.Platform.isTizen3() ||
         shaka.util.Platform.isTizen4()) {
@@ -90,6 +79,14 @@ shaka.polyfill.MediaSource = class {
       shaka.log.info('Using native MSE as-is.');
     }
 
+    if (window.MediaSource || window.ManagedMediaSource) {
+      // TS content is broken on all browsers in general.
+      // See https://github.com/shaka-project/shaka-player/issues/4955
+      // See https://github.com/shaka-project/shaka-player/issues/5278
+      // See https://github.com/shaka-project/shaka-player/issues/6334
+      shaka.polyfill.MediaSource.rejectContainer_('mp2t');
+    }
+
     if (window.MediaSource &&
         MediaSource.isTypeSupported('video/webm; codecs="vp9"') &&
         !MediaSource.isTypeSupported('video/webm; codecs="vp09.00.10.08"')) {
@@ -158,12 +155,25 @@ shaka.polyfill.MediaSource = class {
    * @private
    */
   static rejectContainer_(container) {
-    const isTypeSupported = MediaSource.isTypeSupported;
+    const isTypeSupported =
+        // eslint-disable-next-line no-restricted-syntax
+        MediaSource.isTypeSupported.bind(MediaSource);
 
     MediaSource.isTypeSupported = (mimeType) => {
       const actualContainer = shaka.util.MimeUtils.getContainerType(mimeType);
       return actualContainer != container && isTypeSupported(mimeType);
     };
+
+    if (window.ManagedMediaSource) {
+      const isTypeSupportedManaged =
+          // eslint-disable-next-line no-restricted-syntax
+          ManagedMediaSource.isTypeSupported.bind(ManagedMediaSource);
+
+      window.ManagedMediaSource.isTypeSupported = (mimeType) => {
+        const actualContainer = shaka.util.MimeUtils.getContainerType(mimeType);
+        return actualContainer != container && isTypeSupportedManaged(mimeType);
+      };
+    }
   }
 
   /**
@@ -175,12 +185,25 @@ shaka.polyfill.MediaSource = class {
    * @private
    */
   static rejectCodec_(codec) {
-    const isTypeSupported = MediaSource.isTypeSupported;
+    const isTypeSupported =
+        // eslint-disable-next-line no-restricted-syntax
+        MediaSource.isTypeSupported.bind(MediaSource);
 
     MediaSource.isTypeSupported = (mimeType) => {
       const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
       return actualCodec != codec && isTypeSupported(mimeType);
     };
+
+    if (window.ManagedMediaSource) {
+      const isTypeSupportedManaged =
+          // eslint-disable-next-line no-restricted-syntax
+          ManagedMediaSource.isTypeSupported.bind(ManagedMediaSource);
+
+      window.ManagedMediaSource.isTypeSupported = (mimeType) => {
+        const actualCodec = shaka.util.MimeUtils.getCodecBase(mimeType);
+        return actualCodec != codec && isTypeSupportedManaged(mimeType);
+      };
+    }
   }
 
   /**

package/lib/text/vtt_text_parser.js

@@ -84,51 +84,16 @@ shaka.text.VttTextParser = class {
     // HLS content, which should use X-TIMESTAMP-MAP and periodStart instead.
     let offset = time.vttOffset;
 
-    // Only use 'X-TIMESTAMP-MAP' in sequence mode.
-    // Note that an offset based on the first video
-    // timestamp has already been extracted, and appears in periodStart.
-    if (blocks[0].includes('X-TIMESTAMP-MAP') && this.sequenceMode_) {
-      // https://bit.ly/2K92l7y
-      // The 'X-TIMESTAMP-MAP' header is used in HLS to align text with
-      // the rest of the media.
-      // The header format is 'X-TIMESTAMP-MAP=MPEGTS:n,LOCAL:m'
-      // (the attributes can go in any order)
-      // where n is MPEG-2 time and m is cue time it maps to.
-      // For example 'X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000'
-      // means an offset of 10 seconds
-      // 900000/MPEG_TIMESCALE - cue time.
-      const cueTimeMatch =
-            blocks[0].match(/LOCAL:((?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{3}))/m);
-
-      const mpegTimeMatch = blocks[0].match(/MPEGTS:(\d+)/m);
-      if (cueTimeMatch && mpegTimeMatch) {
-        const parser = new shaka.util.TextParser(cueTimeMatch[1]);
-        const cueTime = shaka.text.VttTextParser.parseTime_(parser);
-        if (cueTime == null) {
-          throw new shaka.util.Error(
-              shaka.util.Error.Severity.CRITICAL,
-              shaka.util.Error.Category.TEXT,
-              shaka.util.Error.Code.INVALID_TEXT_HEADER);
-        }
-
-        let mpegTime = Number(mpegTimeMatch[1]);
-        const mpegTimescale = shaka.text.VttTextParser.MPEG_TIMESCALE_;
-
-        const rolloverSeconds =
-            shaka.text.VttTextParser.TS_ROLLOVER_ / mpegTimescale;
-        let segmentStart = time.segmentStart - time.periodStart;
-        while (segmentStart >= rolloverSeconds) {
-          segmentStart -= rolloverSeconds;
-          mpegTime += shaka.text.VttTextParser.TS_ROLLOVER_;
-        }
-
-        offset = time.periodStart + mpegTime / mpegTimescale - cueTime;
-      }
-    } else if (blocks[0].includes('X-TIMESTAMP-MAP') &&
+    // Only use 'X-TIMESTAMP-MAP' with HLS.  This overrides offset above.
+    if (blocks[0].includes('X-TIMESTAMP-MAP') &&
         this.manifestType_ == shaka.media.ManifestParser.HLS) {
-      // In we use HLS segments mode, with the presence of this tag we need
-      // calculate the offset from the segment startTime.
-      offset = time.segmentStart;
+      if (this.sequenceMode_) {
+        // Compute a different, rollover-based offset for sequence mode.
+        offset = this.computeHlsSequenceModeOffset_(blocks[0], time);
+      } else {
+        // Calculate the offset from the segment startTime.
+        offset = time.segmentStart;
+      }
     }
 
     // Parse VTT regions.
@@ -159,6 +124,48 @@ shaka.text.VttTextParser = class {
     return ret;
   }
 
+  /**
+   * @param {string} headerBlock Contains X-TIMESTAMP-MAP.
+   * @param {shaka.extern.TextParser.TimeContext} time
+   * @return {number}
+   * @private
+   */
+  computeHlsSequenceModeOffset_(headerBlock, time) {
+    // https://bit.ly/2K92l7y
+    // The 'X-TIMESTAMP-MAP' header is used in HLS to align text with
+    // the rest of the media.
+    // The header format is 'X-TIMESTAMP-MAP=MPEGTS:n,LOCAL:m'
+    // (the attributes can go in any order)
+    // where n is MPEG-2 time and m is cue time it maps to.
+    // For example 'X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000'
+    // means an offset of 10 seconds
+    // 900000/MPEG_TIMESCALE - cue time.
+    const cueTimeMatch = headerBlock.match(
+        /LOCAL:((?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{3}))/m);
+    const mpegTimeMatch = headerBlock.match(/MPEGTS:(\d+)/m);
+
+    if (!cueTimeMatch || !mpegTimeMatch) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.TEXT,
+          shaka.util.Error.Code.INVALID_TEXT_HEADER);
+    }
+
+    const parser = new shaka.util.TextParser(cueTimeMatch[1]);
+    const cueTime = shaka.text.VttTextParser.parseTime_(parser);
+    if (cueTime == null) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.TEXT,
+          shaka.util.Error.Code.INVALID_TEXT_HEADER);
+    }
+
+    const mpegTime = Number(mpegTimeMatch[1]);
+    const mpegTimescale = shaka.text.VttTextParser.MPEG_TIMESCALE_;
+
+    return time.periodStart + mpegTime / mpegTimescale - cueTime;
+  }
+
   /**
    * Add default color
    *
@@ -1061,13 +1068,6 @@ shaka.text.VttTextParser = class {
  */
 shaka.text.VttTextParser.MPEG_TIMESCALE_ = 90000;
 
-/**
- * At this value, timestamps roll over in TS content.
- * @const {number}
- * @private
- */
-shaka.text.VttTextParser.TS_ROLLOVER_ = 0x200000000;
-
 /**
  * @const
  * @private {!RegExp}

package/lib/transmuxer/h264.js

@@ -144,7 +144,7 @@ shaka.transmuxer.H264 = class {
         const vSpacingTable = [
           1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1,
         ];
-        if (aspectRatioIdc > 0 && aspectRatioIdc < 16) {
+        if (aspectRatioIdc > 0 && aspectRatioIdc <= 16) {
           hSpacing = hSpacingTable[aspectRatioIdc - 1];
           vSpacing = vSpacingTable[aspectRatioIdc - 1];
         } else if (aspectRatioIdc === 255) {
@@ -267,8 +267,8 @@ shaka.transmuxer.H264 = class {
         naluLength[1] = (size >> 16) & 0xff;
         naluLength[2] = (size >> 8) & 0xff;
         naluLength[3] = size & 0xff;
-        nalusData.push(shaka.util.Uint8ArrayUtils.concat(
-            naluLength, nalu.fullData));
+        nalusData.push(naluLength);
+        nalusData.push(nalu.fullData);
       }
     }
     if (!nalusData.length) {

package/lib/transmuxer/h265.js

@@ -317,7 +317,7 @@ shaka.transmuxer.H265 = class {
         const sarHeightTable = [
           1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1,
         ];
-        if (aspectRatioIdc > 0 && aspectRatioIdc < 16) {
+        if (aspectRatioIdc > 0 && aspectRatioIdc <= 16) {
           sarWidth = sarWidthTable[aspectRatioIdc - 1];
           sarHeight = sarHeightTable[aspectRatioIdc - 1];
         } else if (aspectRatioIdc === 255) {
@@ -652,8 +652,8 @@ shaka.transmuxer.H265 = class {
         naluLength[1] = (size >> 16) & 0xff;
         naluLength[2] = (size >> 8) & 0xff;
         naluLength[3] = size & 0xff;
-        nalusData.push(shaka.util.Uint8ArrayUtils.concat(
-            naluLength, nalu.fullData));
+        nalusData.push(naluLength);
+        nalusData.push(nalu.fullData);
       }
     }
     if (!nalusData.length) {

package/lib/transmuxer/ts_transmuxer.js

@@ -7,6 +7,7 @@
 goog.provide('shaka.transmuxer.TsTransmuxer');
 
 goog.require('shaka.media.Capabilities');
+goog.require('shaka.transmuxer.AacTransmuxer');
 goog.require('shaka.transmuxer.Ac3');
 goog.require('shaka.transmuxer.ADTS');
 goog.require('shaka.transmuxer.Ec3');
@@ -16,6 +17,7 @@ goog.require('shaka.transmuxer.MpegAudio');
 goog.require('shaka.transmuxer.TransmuxerEngine');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Error');
+goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4Generator');
@@ -45,6 +47,9 @@ shaka.transmuxer.TsTransmuxer = class {
 
     /** @private {?shaka.util.TsParser} */
     this.tsParser_ = null;
+
+    /** @private {?shaka.transmuxer.AacTransmuxer} */
+    this.aacTransmuxer_ = null;
   }
 
 
@@ -54,6 +59,10 @@ shaka.transmuxer.TsTransmuxer = class {
    */
   destroy() {
     this.initSegments.clear();
+
+    if (this.aacTransmuxer_) {
+      this.aacTransmuxer_.destroy();
+    }
   }
 
 
@@ -187,14 +196,44 @@ shaka.transmuxer.TsTransmuxer = class {
    */
   transmux(data, stream, reference, duration, contentType) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
+
+    const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
+
+    if (contentType == ContentType.AUDIO &&
+        !shaka.util.TsParser.probe(uint8ArrayData)) {
+      const id3Data = shaka.util.Id3Utils.getID3Data(uint8ArrayData);
+      let offset = id3Data.length;
+      for (; offset < uint8ArrayData.length; offset++) {
+        if (shaka.transmuxer.MpegAudio.probe(uint8ArrayData, offset)) {
+          return Promise.reject(new shaka.util.Error(
+              shaka.util.Error.Severity.CRITICAL,
+              shaka.util.Error.Category.MEDIA,
+              shaka.util.Error.Code.TRANSMUXING_FAILED));
+        }
+      }
+      offset = id3Data.length;
+      for (; offset < uint8ArrayData.length; offset++) {
+        if (shaka.transmuxer.ADTS.probe(uint8ArrayData, offset)) {
+          if (!this.aacTransmuxer_) {
+            this.aacTransmuxer_ =
+                new shaka.transmuxer.AacTransmuxer('audio/aac');
+          }
+          return this.aacTransmuxer_
+              .transmux(data, stream, reference, duration, contentType);
+        }
+      }
+      return Promise.reject(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.TRANSMUXING_FAILED));
+    }
+
     if (!this.tsParser_) {
       this.tsParser_ = new shaka.util.TsParser();
     } else {
       this.tsParser_.clearData();
     }
-    const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
-
-    const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
 
     const tsParser = this.tsParser_.parse(uint8ArrayData);
     const streamInfos = [];

package/lib/util/manifest_parser_utils.js

@@ -203,6 +203,7 @@ shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_ = [
   /^[ae]c-3$/,
   /^ac-4$/,
   /^dts[cex]$/, // DTS Digital Surround (dtsc), DTS Express (dtse), DTS:X (dtsx)
+  /^iamf/,
 ];
 
 

package/lib/util/mp4_parser.js

@@ -271,6 +271,63 @@ shaka.util.Mp4Parser = class {
   }
 
 
+  /**
+   * A callback that tells the Mp4 parser to treat the body of a box as a audio
+   * sample entry.  A audio sample entry has some fixed-sized fields
+   * describing the audio codec parameters, followed by an arbitrary number of
+   * appended children.  Each child is a box.
+   *
+   * @param {!shaka.extern.ParsedBox} box
+   * @export
+   */
+  static audioSampleEntry(box) {
+    // The "reader" starts at the payload, so we need to add the header to the
+    // start position.  The header size varies.
+    const headerSize = shaka.util.Mp4Parser.headerSize(box);
+
+    // 6 bytes reserved
+    // 2 bytes data reference index
+    box.reader.skip(8);
+    // 2 bytes version
+    const version = box.reader.readUint16();
+    // 2 bytes revision (0, could be ignored)
+    // 4 bytes reserved
+    box.reader.skip(6);
+
+    if (version == 2) {
+      // 16 bytes hard-coded values with no comments
+      // 8 bytes sample rate
+      // 4 bytes channel count
+      // 4 bytes hard-coded values with no comments
+      // 4 bytes bits per sample
+      // 4 bytes lpcm flags
+      // 4 bytes sample size
+      // 4 bytes samples per packet
+      box.reader.skip(48);
+    } else {
+      // 2 bytes channel count
+      // 2 bytes bits per sample
+      // 2 bytes compression ID
+      // 2 bytes packet size
+      // 2 bytes sample rate
+      // 2 byte reserved
+      box.reader.skip(12);
+    }
+
+    if (version == 1) {
+      // 4 bytes samples per packet
+      // 4 bytes bytes per packet
+      // 4 bytes bytes per frame
+      // 4 bytes bytes per sample
+      box.reader.skip(16);
+    }
+
+    while (box.reader.hasMoreData() && !box.parser.done_) {
+      box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
+    }
+  }
+
+
   /**
    * Create a callback that tells the Mp4 parser to treat the body of a box as a
    * binary blob and to parse the body's contents using the provided callback.

package/lib/util/platform.js

@@ -535,6 +535,10 @@ shaka.util.Platform = class {
         Platform.isWebOS4() || Platform.isWebOS5()) {
       return false;
     }
+    // See: https://chromium-review.googlesource.com/c/chromium/src/+/4577759
+    if (Platform.isWindows() && Platform.isEdge()) {
+      return false;
+    }
     return true;
   }
 

package/lib/util/ts_parser.js

@@ -10,6 +10,7 @@ goog.require('shaka.Deprecate');
 goog.require('shaka.log');
 goog.require('shaka.util.ExpGolomb');
 goog.require('shaka.util.Id3Utils');
+goog.require('shaka.util.StringUtils');
 goog.require('shaka.util.Uint8ArrayUtils');
 
 
@@ -55,6 +56,12 @@ shaka.util.TsParser = class {
 
     /** @private {!Array.<!Array.<Uint8Array>>} */
     this.id3Data_ = [];
+
+    /** @private {?number} */
+    this.referencePts_ = null;
+
+    /** @private {?number} */
+    this.referenceDts_ = null;
   }
 
   /**
@@ -227,6 +234,7 @@ shaka.util.TsParser = class {
    * @private
    */
   parsePMT_(data, offset) {
+    const StringUtils = shaka.util.StringUtils;
     const result = {
       audio: -1,
       video: -1,
@@ -249,26 +257,52 @@ shaka.util.TsParser = class {
         case 0x06:
           // stream_type 6 can mean a lot of different things in case of DVB.
           // We need to look at the descriptors. Right now, we're only
-          // interested in AC-3 and EC-3 audio, so we do the descriptor parsing
-          // only when we don't have an audio PID yet.
-          if (result.audio == -1 && esInfoLength > 0) {
+          // interested in a few audio and video formats,.
+          if (esInfoLength > 0) {
             let parsePos = offset + 5;
             let remaining = esInfoLength;
+            // Descriptor info: https://www.streamguru.de/mpeg-analyzer/supported-descriptor-list/
             while (remaining > 2) {
               const descriptorId = data[parsePos];
+              const descriptorLen = data[parsePos + 1] + 2;
               switch (descriptorId) {
+                // Registration descriptor
+                case 0x05: {
+                  const registrationData =
+                      data.subarray(parsePos + 2, parsePos + descriptorLen);
+                  const registration =
+                      StringUtils.fromCharCode(registrationData);
+                  if (result.audio == -1 && registration === 'Opus') {
+                    result.audio = pid;
+                    result.audioCodec = 'opus';
+                  } else if (result.video == -1 && registration === 'AV01') {
+                    result.video = pid;
+                    result.videoCodec = 'av1';
+                  }
+                  break;
+                }
                 // DVB Descriptor for AC-3
                 case 0x6a:
-                  result.audio = pid;
-                  result.audioCodec = 'ac3';
+                  if (result.audio == -1) {
+                    result.audio = pid;
+                    result.audioCodec = 'ac3';
+                  }
                   break;
                 // DVB Descriptor for EC-3
                 case 0x7a:
-                  result.audio = pid;
-                  result.audioCodec = 'ec3';
+                  if (result.audio == -1) {
+                    result.audio = pid;
+                    result.audioCodec = 'ec3';
+                  }
+                  break;
+                // DVB Descriptor for AAC
+                case 0x7c:
+                  if (result.audio == -1) {
+                    result.audio = pid;
+                    result.audioCodec = 'aac';
+                  }
                   break;
               }
-              const descriptorLen = data[parsePos + 1] + 2;
               parsePos += descriptorLen;
               remaining -= descriptorLen;
             }
@@ -284,6 +318,13 @@ shaka.util.TsParser = class {
             result.audioCodec = 'aac';
           }
           break;
+        // LOAS/LATM AAC
+        case 0x11:
+          if (result.audio == -1) {
+            result.audio = pid;
+            result.audioCodec = 'aac-loas';
+          }
+          break;
         // Packetized metadata (ID3)
         case 0x15:
           if (result.id3 == -1) {
@@ -390,22 +431,36 @@ shaka.util.TsParser = class {
       // the PTS and DTS are not written out directly. For information
       // on how they are encoded, see
       // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
-      pes.pts =
+      const pts =
         (data[9] & 0x0e) * 536870912 + // 1 << 29
         (data[10] & 0xff) * 4194304 + // 1 << 22
         (data[11] & 0xfe) * 16384 + // 1 << 14
         (data[12] & 0xff) * 128 + // 1 << 7
         (data[13] & 0xfe) / 2;
 
+      if (this.referencePts_ == null) {
+        this.referencePts_ = pts;
+      }
+
+      pes.pts = this.handleRollover_(pts, this.referencePts_);
+      this.referencePts_ = pes.pts;
+
       pes.dts = pes.pts;
       if (ptsDtsFlags & 0x40) {
-        pes.dts =
+        const dts =
           (data[14] & 0x0e) * 536870912 + // 1 << 29
           (data[15] & 0xff) * 4194304 + // 1 << 22
           (data[16] & 0xfe) * 16384 + // 1 << 14
           (data[17] & 0xff) * 128 + // 1 << 7
           (data[18] & 0xfe) / 2;
+
+        if (this.referenceDts_ == null) {
+          this.referenceDts_ = dts;
+        }
+
+        pes.dts = this.handleRollover_(dts, this.referenceDts_);
       }
+      this.referenceDts_ = pes.dts;
     }
 
     const pesHdrLen = data[8];
@@ -1069,6 +1124,40 @@ shaka.util.TsParser = class {
     return ('0' + x.toString(16).toUpperCase()).slice(-2);
   }
 
+  /**
+   * @param {number} value
+   * @param {number} reference
+   * @return {number}
+   * @private
+   */
+  handleRollover_(value, reference) {
+    const MAX_TS = 8589934592;
+    const RO_THRESH = 4294967296;
+
+    let direction = 1;
+
+    if (value > reference) {
+      // If the current timestamp value is greater than our reference timestamp
+      // and we detect a timestamp rollover, this means the roll over is
+      // happening in the opposite direction.
+      // Example scenario: Enter a long stream/video just after a rollover
+      // occurred. The reference point will be set to a small number, e.g. 1.
+      // The user then seeks backwards over the rollover point. In loading this
+      // segment, the timestamp values will be very large, e.g. 2^33 - 1. Since
+      // this comes before the data we loaded previously, we want to adjust the
+      // time stamp to be `value - 2^33`.
+      direction = -1;
+    }
+
+    // Note: A seek forwards or back that is greater than the RO_THRESH
+    // (2^32, ~13 hours) will cause an incorrect adjustment.
+    while (Math.abs(reference - value) > RO_THRESH) {
+      value += (direction * MAX_TS);
+    }
+
+    return value;
+  }
+
   /**
    * Check if the passed data corresponds to an MPEG2-TS
    *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.7.11",
+  "version": "4.7.12",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [

package/lib/polyfill/storage_estimate.js

@@ -1,57 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-goog.provide('shaka.polyfill.StorageEstimate');
-
-goog.require('shaka.polyfill');
-
-
-/**
- * @summary A polyfill to provide navigator.storage.estimate in old
- * webkit browsers.
- * See: https://developers.google.com/web/updates/2017/08/estimating-available-storage-space#the-present
- * @export
- */
-shaka.polyfill.StorageEstimate = class {
-  /**
-   * Install the polyfill if needed.
-   * @export
-   */
-  static install() {
-    if (navigator.storage && navigator.storage.estimate) {
-      // No need.
-      return;
-    }
-
-    if (navigator.webkitTemporaryStorage &&
-        navigator.webkitTemporaryStorage.queryUsageAndQuota) {
-      if (!('storage' in navigator)) {
-        navigator.storage = /** @type {!StorageManager} */ ({});
-      }
-      navigator.storage.estimate =
-          shaka.polyfill.StorageEstimate.storageEstimate_;
-    }
-  }
-
-  /**
-   * @this {StorageManager}
-   * @return {!Promise}
-   * @private
-   */
-  static storageEstimate_() {
-    return new Promise((resolve, reject) => {
-      navigator.webkitTemporaryStorage.queryUsageAndQuota(
-          (usage, quota) => {
-            resolve({usage: usage, quota: quota});
-          },
-          reject,
-      );
-    });
-  }
-};
-
-
-shaka.polyfill.register(shaka.polyfill.StorageEstimate.install);