shaka-player 4.1.4 → 4.1.6

package/lib/media/streaming_engine.js

@@ -320,8 +320,14 @@ shaka.media.StreamingEngine = class {
    * @param {number=} safeMargin
    * @param {boolean=} force
    *   If true, reload the variant even if it did not change.
+   * @param {boolean=} adaptation
+   *   If true, update the media state to indicate MediaSourceEngine should
+   *   reset the timestamp offset to ensure the new track segments are correctly
+   *   placed on the timeline.
    */
-  switchVariant(variant, clearBuffer = false, safeMargin = 0, force = false) {
+  switchVariant(
+      variant, clearBuffer = false, safeMargin = 0, force = false,
+      adaptation = false) {
     this.currentVariant_ = variant;
 
     if (!this.startupComplete_) {
@@ -332,12 +338,14 @@ shaka.media.StreamingEngine = class {
     if (variant.video) {
       this.switchInternal_(
           variant.video, /* clearBuffer= */ clearBuffer,
-          /* safeMargin= */ safeMargin, /* force= */ force);
+          /* safeMargin= */ safeMargin, /* force= */ force,
+          /* adaptation= */ adaptation);
     }
     if (variant.audio) {
       this.switchInternal_(
           variant.audio, /* clearBuffer= */ clearBuffer,
-          /* safeMargin= */ safeMargin, /* force= */ force);
+          /* safeMargin= */ safeMargin, /* force= */ force,
+          /* adaptation= */ adaptation);
     }
   }
 
@@ -383,9 +391,13 @@ shaka.media.StreamingEngine = class {
    * @param {number} safeMargin
    * @param {boolean} force
    *   If true, reload the text stream even if it did not change.
+   * @param {boolean=} adaptation
+   *   If true, update the media state to indicate MediaSourceEngine should
+   *   reset the timestamp offset to ensure the new track segments are correctly
+   *   placed on the timeline.
    * @private
    */
-  switchInternal_(stream, clearBuffer, safeMargin, force) {
+  switchInternal_(stream, clearBuffer, safeMargin, force, adaptation) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const type = /** @type {!ContentType} */(stream.type);
     const mediaState = this.mediaStates_.get(type);
@@ -440,6 +452,7 @@ shaka.media.StreamingEngine = class {
 
     mediaState.stream = stream;
     mediaState.segmentIterator = null;
+    mediaState.adaptation = !!adaptation;
 
     const streamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
     shaka.log.debug('switch: switching to Stream ' + streamTag);
@@ -769,12 +782,11 @@ shaka.media.StreamingEngine = class {
     const mediaSourceEngine = this.playerInterface_.mediaSourceEngine;
     const forceTransmuxTS = this.config_.forceTransmuxTS;
 
-
     await mediaSourceEngine.init(streamsByType, forceTransmuxTS,
         this.manifest_.sequenceMode);
     this.destroyer_.ensureNotDestroyed();
 
-    this.setDuration_();
+    this.updateDuration();
 
     for (const type of streamsByType.keys()) {
       const stream = streamsByType.get(type);
@@ -824,9 +836,8 @@ shaka.media.StreamingEngine = class {
 
   /**
    * Sets the MediaSource's duration.
-   * @private
    */
-  setDuration_() {
+  updateDuration() {
     const duration = this.manifest_.presentationTimeline.getDuration();
     if (duration < Infinity) {
       this.playerInterface_.mediaSourceEngine.setDuration(duration);
@@ -1001,7 +1012,11 @@ shaka.media.StreamingEngine = class {
     const timeUntilEnd =
         this.manifest_.presentationTimeline.getDuration() - timeNeeded;
     const oneMicrosecond = 1e-6;
-    if (timeUntilEnd < oneMicrosecond) {
+
+    const bufferEnd =
+      this.playerInterface_.mediaSourceEngine.bufferEnd(mediaState.type);
+
+    if (timeUntilEnd < oneMicrosecond && !!bufferEnd) {
       // We shouldn't rebuffer if the playhead is close to the end of the
       // presentation.
       shaka.log.debug(logPrefix, 'buffered to end of presentation');
@@ -1031,8 +1046,6 @@ shaka.media.StreamingEngine = class {
       return this.config_.updateIntervalSeconds / 2;
     }
 
-    const bufferEnd =
-        this.playerInterface_.mediaSourceEngine.bufferEnd(mediaState.type);
     const reference = this.getSegmentReferenceNeeded_(
         mediaState, presentationTime, bufferEnd);
     if (!reference) {
@@ -1235,7 +1248,16 @@ shaka.media.StreamingEngine = class {
       // Enable MP4 low latency streaming with ReadableStream chunked data.
       if (this.config_.lowLatencyMode && isReadableStreamSupported && isMP4) {
         let remaining = new Uint8Array(0);
+        let processingResult = false;
+        let callbackCalled = false;
         const streamDataCallback = async (data) => {
+          if (processingResult) {
+            // If the fallback result processing was triggered, don't also
+            // append the buffer here.  In theory this should never happen,
+            // but it does on some older TVs.
+            return;
+          }
+          callbackCalled = true;
           this.destroyer_.ensureNotDestroyed();
           if (this.fatalError_) {
             return;
@@ -1266,7 +1288,33 @@ shaka.media.StreamingEngine = class {
           }
         };
 
-        await this.fetch_(mediaState, reference, streamDataCallback);
+        const result =
+            await this.fetch_(mediaState, reference, streamDataCallback);
+        if (!callbackCalled) {
+          // In some environments, we might be forced to use network plugins
+          // that don't support streamDataCallback. In those cases, as a
+          // fallback, append the buffer here.
+          processingResult = true;
+          this.destroyer_.ensureNotDestroyed();
+          if (this.fatalError_) {
+            return;
+          }
+
+          // If the text stream gets switched between fetch_() and append_(),
+          // the new text parser is initialized, but the new init segment is
+          // not fetched yet.  That would cause an error in
+          // TextParser.parseMedia().
+          // See http://b/168253400
+          if (mediaState.waitingToClearBuffer) {
+            shaka.log.info(logPrefix, 'waitingToClearBuffer, skip append');
+            mediaState.performingUpdate = false;
+            this.scheduleUpdate_(mediaState, 0);
+            return;
+          }
+
+          await this.append_(
+              mediaState, presentationTime, stream, reference, result);
+        }
       } else {
         if (this.config_.lowLatencyMode && !isReadableStreamSupported) {
           shaka.log.warning('Low latency streaming mode is enabled, but ' +
@@ -1554,6 +1602,8 @@ shaka.media.StreamingEngine = class {
             shaka.log.v1(logPrefix, 'appending init segment');
             const hasClosedCaptions = mediaState.stream.closedCaptions &&
                 mediaState.stream.closedCaptions.size > 0;
+            await this.playerInterface_.beforeAppendSegment(
+                mediaState.type, initSegment);
             await this.playerInterface_.mediaSourceEngine.appendBuffer(
                 mediaState.type, initSegment, /* reference= */ null,
                 hasClosedCaptions);
@@ -1604,14 +1654,21 @@ shaka.media.StreamingEngine = class {
     shaka.log.v1(logPrefix, 'appending media segment at',
         (reference.syncTime == null ? 'unknown' : reference.syncTime));
 
+    // 'seeked' or 'adaptation' triggered logic applies only to this
+    // appendBuffer() call.
     const seeked = mediaState.seeked;
     mediaState.seeked = false;
+    const adaptation = mediaState.adaptation;
+    mediaState.adaptation = false;
+
+    await this.playerInterface_.beforeAppendSegment(mediaState.type, segment);
     await this.playerInterface_.mediaSourceEngine.appendBuffer(
         mediaState.type,
         segment,
         reference,
         hasClosedCaptions,
-        seeked);
+        seeked,
+        adaptation);
     this.destroyer_.ensureNotDestroyed();
     shaka.log.v2(logPrefix, 'appended media segment');
   }
@@ -1988,7 +2045,9 @@ shaka.media.StreamingEngine = class {
  *   onEvent: function(!Event),
  *   onManifestUpdate: function(),
  *   onSegmentAppended: function(),
- *   onInitSegmentAppended: function(!number,!shaka.media.InitSegmentReference)
+ *   onInitSegmentAppended: function(!number,!shaka.media.InitSegmentReference),
+ *   beforeAppendSegment: function(
+ *     shaka.util.ManifestParserUtils.ContentType,!BufferSource):Promise
  * }}
  *
  * @property {function():number} getPresentationTime
@@ -2016,6 +2075,9 @@ shaka.media.StreamingEngine = class {
  * @property
  *  {function(!number, !shaka.media.InitSegmentReference)} onInitSegmentAppended
  *   Called when an init segment is appended to a MediaSource.
+ * @property {!function(shaka.util.ManifestParserUtils.ContentType,
+ *   !BufferSource):Promise} beforeAppendSegment
+ *   A function called just before appending to the source buffer.
  */
 shaka.media.StreamingEngine.PlayerInterface;
 
@@ -2039,6 +2101,7 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   clearBufferSafeMargin: number,
  *   clearingBuffer: boolean,
  *   seeked: boolean,
+ *   adaptation: boolean,
  *   recovering: boolean,
  *   hasError: boolean,
  *   operation: shaka.net.NetworkingEngine.PendingRequest
@@ -2085,6 +2148,8 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   True indicates that the buffer is being cleared.
   * @property {boolean} seeked
  *   True indicates that the presentation just seeked.
+  * @property {boolean} adaptation
+ *   True indicates that the presentation just automatically switched variants.
  * @property {boolean} recovering
  *   True indicates that the last segment was not appended because it could not
  *   fit in the buffer.

package/lib/offline/indexeddb/storage_mechanism.js

@@ -16,6 +16,7 @@ goog.require('shaka.offline.indexeddb.V5StorageCell');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.PublicPromise');
 goog.require('shaka.util.Platform');
+goog.require('shaka.util.Timer');
 
 
 /**
@@ -55,8 +56,25 @@ shaka.offline.indexeddb.StorageMechanism = class {
     const version = shaka.offline.indexeddb.StorageMechanism.VERSION;
 
     const p = new shaka.util.PublicPromise();
+
+    // Add a timeout mechanism, for the (rare?) case where no callbacks are
+    // called at all, so that this method doesn't hang forever.
+    let timedOut = false;
+    const timeOutTimer = new shaka.util.Timer(() => {
+      timedOut = true;
+      p.reject(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.STORAGE,
+          shaka.util.Error.Code.INDEXED_DB_INIT_TIMED_OUT));
+    });
+    timeOutTimer.tickAfter(2);
+
     const open = window.indexedDB.open(name, version);
     open.onsuccess = (event) => {
+      if (timedOut) {
+        // Too late, we have already given up on opening the storage mechanism.
+        return;
+      }
       const db = open.result;
       this.db_ = db;
       this.v1_ = shaka.offline.indexeddb.StorageMechanism.createV1_(db);
@@ -68,6 +86,7 @@ shaka.offline.indexeddb.StorageMechanism = class {
       this.v5_ = shaka.offline.indexeddb.StorageMechanism.createV5_(db);
       this.sessions_ =
           shaka.offline.indexeddb.StorageMechanism.createEmeSessionCell_(db);
+      timeOutTimer.stop();
       p.resolve();
     };
     open.onupgradeneeded = (event) => {
@@ -75,11 +94,16 @@ shaka.offline.indexeddb.StorageMechanism = class {
       this.createStores_(open.result);
     };
     open.onerror = (event) => {
+      if (timedOut) {
+        // Too late, we have already given up on opening the storage mechanism.
+        return;
+      }
       p.reject(new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.STORAGE,
           shaka.util.Error.Code.INDEXED_DB_ERROR,
           open.error));
+      timeOutTimer.stop();
 
       // Firefox will raise an error on the main thread unless we stop it here.
       event.preventDefault();

package/lib/offline/storage.js

@@ -1169,6 +1169,7 @@ shaka.offline.Storage = class {
       isLowLatencyMode: () => false,
       isAutoLowLatencyMode: () => false,
       enableLowLatencyMode: () => {},
+      updateDuration: () => {},
     };
 
     parser.configure(config.manifest);

package/lib/player.js

@@ -1770,6 +1770,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       enableLowLatencyMode: () => {
         this.configure('streaming.lowLatencyMode', true);
       },
+      updateDuration: () => {
+        if (this.streamingEngine_) {
+          this.streamingEngine_.updateDuration();
+        }
+      },
     };
 
     const startTime = Date.now() / 1000;
@@ -2945,6 +2950,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           this.qualityObserver_.addMediaQualityChange(mediaQuality, position);
         }
       },
+      beforeAppendSegment: (contentType, segment) => {
+        return this.drmEngine_.parseInbandPssh(contentType, segment);
+      },
     };
 
     return new shaka.media.StreamingEngine(this.manifest_, playerInterface);
@@ -3831,8 +3839,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         return;
       }
 
-      this.switchVariant_(variant, /* fromAdaptation= */ false, clearBuffer,
-          safeMargin);
+      this.switchVariant_(
+          variant, /* fromAdaptation= */ false, clearBuffer, safeMargin);
 
       // Workaround for
       // https://github.com/shaka-project/shaka-player/issues/1299
@@ -5369,7 +5377,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const currentVariant = this.streamingEngine_.getCurrentVariant();
     if (variant == currentVariant) {
       shaka.log.debug('Variant already selected.');
-      // If you want to clear the buffer, we force to reselect the same variant
+      // If you want to clear the buffer, we force to reselect the same variant.
+      // We don't need to reset the timestampOffset since it's the same variant,
+      // so 'adaptation' isn't passed here.
       if (clearBuffer) {
         this.streamingEngine_.switchVariant(variant, clearBuffer, safeMargin,
             /* force= */ true);
@@ -5379,7 +5389,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     // Add entries to the history.
     this.addVariantToSwitchHistory_(variant, fromAdaptation);
-    this.streamingEngine_.switchVariant(variant, clearBuffer, safeMargin);
+    this.streamingEngine_.switchVariant(
+        variant, clearBuffer, safeMargin, /* force= */ undefined,
+        /* adaptation= */ fromAdaptation);
     let oldTrack = null;
     if (currentVariant) {
       oldTrack = shaka.util.StreamUtils.variantToTrack(currentVariant);
@@ -6563,7 +6575,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.1.4-uncompiled';
+shaka.Player.version = 'v4.1.6-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/media_capabilities.js

@@ -24,8 +24,9 @@ shaka.polyfill.MediaCapabilities = class {
    * @export
    */
   static install() {
-    // Since MediaCapabilities is not fully supported on some Chromecast yet,
-    // we should always install polyfill for all Chromecast not Android-based.
+    // Since MediaCapabilities implementation is buggy on the Chromecast
+    // platform (see https://github.com/shaka-project/shaka-player/issues/4569),
+    // we should always install polyfills on all Chromecast models.
     // TODO: re-evaluate MediaCapabilities in the future versions of Chromecast.
     // Since MediaCapabilities implementation is buggy in Apple browsers, we
     // should always install polyfill for Apple browsers.
@@ -43,18 +44,18 @@ shaka.polyfill.MediaCapabilities = class {
     // should always install polyfill for Tizen browsers.
     // Since MediaCapabilities implementation is buggy in WebOS browsers, we
     // should always install polyfill for WebOS browsers.
+    // Since MediaCapabilities implementation is buggy in EOS browsers, we
+    // should always install polyfill for EOS browsers.
     let canUseNativeMCap = true;
     if (shaka.util.Platform.isApple() ||
         shaka.util.Platform.isPS5() ||
         shaka.util.Platform.isPS4() ||
         shaka.util.Platform.isWebOS() ||
         shaka.util.Platform.isTizen() ||
-        shaka.util.Platform.isChromecast()) {
+        shaka.util.Platform.isChromecast() ||
+        shaka.util.Platform.isEOS()) {
       canUseNativeMCap = false;
     }
-    if (shaka.util.Platform.isAndroidCastDevice()) {
-      canUseNativeMCap = true;
-    }
     if (canUseNativeMCap && navigator.mediaCapabilities) {
       shaka.log.info(
           'MediaCapabilities: Native mediaCapabilities support found.');

package/lib/text/ttml_text_parser.js

@@ -49,8 +49,6 @@ shaka.text.TtmlTextParser = class {
     const ttsNs = TtmlTextParser.styleNs_;
     const str = shaka.util.StringUtils.fromUTF8(data);
     const cues = [];
-    const parser = new DOMParser();
-    let xml = null;
 
     // dont try to parse empty string as
     // DOMParser will not throw error but return an errored xml
@@ -58,9 +56,8 @@ shaka.text.TtmlTextParser = class {
       return cues;
     }
 
-    try {
-      xml = parser.parseFromString(str, 'text/xml');
-    } catch (exception) {
+    const tt = XmlUtils.parseXmlString(str, 'tt');
+    if (!tt) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.TEXT,
@@ -68,104 +65,89 @@ shaka.text.TtmlTextParser = class {
           'Failed to parse TTML.');
     }
 
-    if (xml) {
-      const parserError = xml.getElementsByTagName('parsererror')[0];
-      if (parserError) {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.TEXT,
-            shaka.util.Error.Code.INVALID_XML,
-            parserError.textContent);
-      }
-
-      const tt = xml.getElementsByTagName('tt')[0];
-      // TTML should always have tt element.
-      if (!tt) {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.TEXT,
-            shaka.util.Error.Code.INVALID_XML,
-            'TTML does not contain <tt> tag.');
-      }
-
-      const body = tt.getElementsByTagName('body')[0];
-      if (!body) {
-        return [];
-      }
+    const body = tt.getElementsByTagName('body')[0];
+    if (!body) {
+      return [];
+    }
 
-      // Get the framerate, subFrameRate and frameRateMultiplier if applicable.
-      const frameRate = XmlUtils.getAttributeNSList(tt, ttpNs, 'frameRate');
-      const subFrameRate = XmlUtils.getAttributeNSList(
-          tt, ttpNs, 'subFrameRate');
-      const frameRateMultiplier =
-          XmlUtils.getAttributeNSList(tt, ttpNs, 'frameRateMultiplier');
-      const tickRate = XmlUtils.getAttributeNSList(tt, ttpNs, 'tickRate');
+    // Get the framerate, subFrameRate and frameRateMultiplier if applicable.
+    const frameRate = XmlUtils.getAttributeNSList(tt, ttpNs, 'frameRate');
+    const subFrameRate = XmlUtils.getAttributeNSList(
+        tt, ttpNs, 'subFrameRate');
+    const frameRateMultiplier =
+        XmlUtils.getAttributeNSList(tt, ttpNs, 'frameRateMultiplier');
+    const tickRate = XmlUtils.getAttributeNSList(tt, ttpNs, 'tickRate');
 
-      const cellResolution = XmlUtils.getAttributeNSList(
-          tt, ttpNs, 'cellResolution');
-      const spaceStyle = tt.getAttribute('xml:space') || 'default';
-      const extent = XmlUtils.getAttributeNSList(tt, ttsNs, 'extent');
+    const cellResolution = XmlUtils.getAttributeNSList(
+        tt, ttpNs, 'cellResolution');
+    const spaceStyle = tt.getAttribute('xml:space') || 'default';
+    const extent = XmlUtils.getAttributeNSList(tt, ttsNs, 'extent');
 
-      if (spaceStyle != 'default' && spaceStyle != 'preserve') {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.TEXT,
-            shaka.util.Error.Code.INVALID_XML,
-            'Invalid xml:space value: ' + spaceStyle);
-      }
-      const whitespaceTrim = spaceStyle == 'default';
+    if (spaceStyle != 'default' && spaceStyle != 'preserve') {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.TEXT,
+          shaka.util.Error.Code.INVALID_XML,
+          'Invalid xml:space value: ' + spaceStyle);
+    }
+    const whitespaceTrim = spaceStyle == 'default';
 
-      const rateInfo = new TtmlTextParser.RateInfo_(
-          frameRate, subFrameRate, frameRateMultiplier, tickRate);
+    const rateInfo = new TtmlTextParser.RateInfo_(
+        frameRate, subFrameRate, frameRateMultiplier, tickRate);
 
-      const cellResolutionInfo =
-        TtmlTextParser.getCellResolution_(cellResolution);
+    const cellResolutionInfo =
+      TtmlTextParser.getCellResolution_(cellResolution);
 
-      const metadata = tt.getElementsByTagName('metadata')[0];
-      const metadataElements = metadata ? XmlUtils.getChildren(metadata) : [];
-      const styles = Array.from(tt.getElementsByTagName('style'));
-      const regionElements = Array.from(tt.getElementsByTagName('region'));
+    const metadata = tt.getElementsByTagName('metadata')[0];
+    const metadataElements = metadata ? XmlUtils.getChildren(metadata) : [];
+    const styles = Array.from(tt.getElementsByTagName('style'));
+    const regionElements = Array.from(tt.getElementsByTagName('region'));
 
-      const cueRegions = [];
-      for (const region of regionElements) {
-        const cueRegion =
-            TtmlTextParser.parseCueRegion_(region, styles, extent);
-        if (cueRegion) {
-          cueRegions.push(cueRegion);
-        }
+    const cueRegions = [];
+    for (const region of regionElements) {
+      const cueRegion =
+          TtmlTextParser.parseCueRegion_(region, styles, extent);
+      if (cueRegion) {
+        cueRegions.push(cueRegion);
       }
+    }
+
+    // A <body> element should only contain <div> elements, not <p> or <span>
+    // elements.  We used to allow this, but it is non-compliant, and the
+    // loose nature of our previous parser made it difficult to implement TTML
+    // nesting more fully.
+    if (XmlUtils.findChildren(body, 'p').length) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.TEXT,
+          shaka.util.Error.Code.INVALID_TEXT_CUE,
+          '<p> can only be inside <div> in TTML');
+    }
 
-      // A <body> element should only contain <div> elements, not <p> or <span>
-      // elements.  We used to allow this, but it is non-compliant, and the
-      // loose nature of our previous parser made it difficult to implement TTML
-      // nesting more fully.
-      if (XmlUtils.findChildren(body, 'p').length) {
+    for (const div of XmlUtils.findChildren(body, 'div')) {
+      // A <div> element should only contain <p>, not <span>.
+      if (XmlUtils.findChildren(div, 'span').length) {
         throw new shaka.util.Error(
             shaka.util.Error.Severity.CRITICAL,
             shaka.util.Error.Category.TEXT,
             shaka.util.Error.Code.INVALID_TEXT_CUE,
-            '<p> can only be inside <div> in TTML');
-      }
-
-      for (const div of XmlUtils.findChildren(body, 'div')) {
-        // A <div> element should only contain <p>, not <span>.
-        if (XmlUtils.findChildren(div, 'span').length) {
-          throw new shaka.util.Error(
-              shaka.util.Error.Severity.CRITICAL,
-              shaka.util.Error.Category.TEXT,
-              shaka.util.Error.Code.INVALID_TEXT_CUE,
-              '<span> can only be inside <p> in TTML');
-        }
+            '<span> can only be inside <p> in TTML');
       }
+    }
 
-      const cue = TtmlTextParser.parseCue_(
-          body, time.periodStart, rateInfo, metadataElements, styles,
-          regionElements, cueRegions, whitespaceTrim,
-          cellResolutionInfo, /* parentCueElement= */ null,
-          /* isContent= */ false);
-      if (cue) {
-        cues.push(cue);
+    const cue = TtmlTextParser.parseCue_(
+        body, time.periodStart, rateInfo, metadataElements, styles,
+        regionElements, cueRegions, whitespaceTrim,
+        cellResolutionInfo, /* parentCueElement= */ null,
+        /* isContent= */ false);
+    if (cue) {
+      // According to the TTML spec, backgrounds default to transparent.
+      // So default the background of the top-level element to transparent.
+      // Nested elements may override that background color already.
+      if (!cue.backgroundColor) {
+        cue.backgroundColor = 'transparent';
       }
+      cues.push(cue);
     }
 
     return cues;

package/lib/text/vtt_text_parser.js

@@ -105,7 +105,7 @@ shaka.text.VttTextParser = class {
 
         const rolloverSeconds =
             shaka.text.VttTextParser.TS_ROLLOVER_ / mpegTimescale;
-        let segmentStart = time.segmentStart;
+        let segmentStart = time.segmentStart - time.periodStart;
         while (segmentStart >= rolloverSeconds) {
           segmentStart -= rolloverSeconds;
           mpegTime += shaka.text.VttTextParser.TS_ROLLOVER_;

package/lib/util/error.js

@@ -1001,6 +1001,13 @@ shaka.util.Error.Code = {
    */
   'MODIFY_OPERATION_NOT_SUPPORTED': 9016,
 
+  /**
+   * When attempting to open an indexedDB instance, nothing happened for long
+   * enough for us to time out.  This keeps the storage mechanism from hanging
+   * indefinitely, if neither the success nor error callbacks are called.
+   */
+  'INDEXED_DB_INIT_TIMED_OUT': 9017,
+
   /**
    * CS IMA SDK, required for ad insertion, has not been included on the page.
    */

package/lib/util/periods.js

@@ -1180,15 +1180,6 @@ shaka.util.PeriodCombiner = class {
       return false;
     }
 
-    // If the language doesn't match, but the candidate is the "primary"
-    // language, then that should be preferred as a fallback.
-    if (!best.primary && candidate.primary) {
-      return true;
-    }
-    if (best.primary && !candidate.primary) {
-      return false;
-    }
-
     // If language-based differences haven't decided this, look at roles.  If
     // the candidate has more roles in common with the output, upgrade to the
     // candidate.
@@ -1222,6 +1213,15 @@ shaka.util.PeriodCombiner = class {
       return false;
     }
 
+    // If the language doesn't match, but the candidate is the "primary"
+    // language, then that should be preferred as a fallback.
+    if (!best.primary && candidate.primary) {
+      return true;
+    }
+    if (best.primary && !candidate.primary) {
+      return false;
+    }
+
     // If language-based and role-based features are equivalent, take the audio
     // with the closes channel count to the output.
     const channelsBetterOrWorse =

package/lib/util/platform.js

@@ -164,13 +164,27 @@ shaka.util.Platform = class {
   }
 
   /**
-   * Check if the current platform is a Android-based Cast devices.
+   * Returns a major version number for Chrome, or Chromium-based browsers.
    *
-   * @return {boolean}
+   * For example:
+   *   - Chrome 106.0.5249.61 returns 106.
+   *   - Edge 106.0.1370.34 returns 106 (since this is based on Chromium).
+   *   - Safari returns null (since this is independent of Chromium).
+   *
+   * @return {?number} A major version number or null if not Chromium-based.
    */
-  static isAndroidCastDevice() {
-    return shaka.util.Platform.isChromecast() &&
-        shaka.util.Platform.userAgentContains_('Android');
+  static chromeVersion() {
+    if (!shaka.util.Platform.userAgentContains_('Chrome')) {
+      return null;
+    }
+
+    // Looking for something like "Chrome/106.0.0.0".
+    const match = navigator.userAgent.match(/Chrome\/(\d+)/);
+    if (match) {
+      return parseInt(match[1], /* base= */ 10);
+    }
+
+    return null;
   }
 
   /**