shaka-player 4.7.12 → 4.7.14

package/lib/media/segment_index.js

@@ -363,26 +363,27 @@ shaka.media.SegmentIndex = class {
 
     // Adjust the last SegmentReference.
     const lastReference = this.references[this.references.length - 1];
-    this.references[this.references.length - 1] =
-        new shaka.media.SegmentReference(
-            lastReference.startTime,
-            /* endTime= */ windowEnd,
-            lastReference.getUrisInner,
-            lastReference.startByte,
-            lastReference.endByte,
-            lastReference.initSegmentReference,
-            lastReference.timestampOffset,
-            lastReference.appendWindowStart,
-            lastReference.appendWindowEnd,
-            lastReference.partialReferences,
-            lastReference.tilesLayout,
-            lastReference.tileDuration,
-            lastReference.syncTime,
-            lastReference.status,
-            lastReference.aes128Key,
-        );
-    this.references[this.references.length - 1].discontinuitySequence =
-        lastReference.discontinuitySequence;
+    const newReference = new shaka.media.SegmentReference(
+        lastReference.startTime,
+        /* endTime= */ windowEnd,
+        lastReference.getUrisInner,
+        lastReference.startByte,
+        lastReference.endByte,
+        lastReference.initSegmentReference,
+        lastReference.timestampOffset,
+        lastReference.appendWindowStart,
+        lastReference.appendWindowEnd,
+        lastReference.partialReferences,
+        lastReference.tilesLayout,
+        lastReference.tileDuration,
+        lastReference.syncTime,
+        lastReference.status,
+        lastReference.aes128Key,
+    );
+    newReference.mimeType = lastReference.mimeType;
+    newReference.codecs = lastReference.codecs;
+    newReference.discontinuitySequence = lastReference.discontinuitySequence;
+    this.references[this.references.length - 1] = newReference;
   }
 
 
@@ -693,6 +694,16 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
     this.indexes_ = [];
   }
 
+  /**
+   * @override
+   * @export
+   */
+  forEachTopLevelReference(fn) {
+    for (const index of this.indexes_) {
+      index.forEachTopLevelReference(fn);
+    }
+  }
+
   /**
    * @override
    * @export

package/lib/media/segment_reference.js

@@ -598,6 +598,18 @@ shaka.media.SegmentReference = class {
       this.offset(offset);
     }
   }
+
+  /**
+   * Updates the init segment reference and propagates the update to all partial
+   * references.
+   * @param {shaka.media.InitSegmentReference} initSegmentReference
+   */
+  updateInitSegmentReference(initSegmentReference) {
+    this.initSegmentReference = initSegmentReference;
+    for (const partialReference of this.partialReferences) {
+      partialReference.updateInitSegmentReference(initSegmentReference);
+    }
+  }
 };
 
 

package/lib/media/streaming_engine.js

@@ -881,7 +881,6 @@ shaka.media.StreamingEngine = class {
       // The playhead might be seeking on startup, if a start time is set, so
       // start "seeked" as true.
       seeked: true,
-      needsResync: false,
       recovering: false,
       hasError: false,
       operation: null,
@@ -1248,11 +1247,6 @@ shaka.media.StreamingEngine = class {
       shaka.log.v1(
           logPrefix, 'looking up segment from new stream endTime:', time);
 
-      // Using a new iterator means we need to resync the stream in sequence
-      // mode.  The buffered range might not align perfectly with the last
-      // segment end time, so we may end up repeating a segment.  Resyncing
-      // makes this safe to do.
-      mediaState.needsResync = true;
       mediaState.segmentIterator =
           mediaState.stream.segmentIndex.getIteratorForTime(time);
       const ref = mediaState.segmentIterator &&
@@ -1730,7 +1724,7 @@ shaka.media.StreamingEngine = class {
       const isResetMediaSourceNecessary =
           mediaState.lastCodecs && mediaState.lastMimeType &&
           this.playerInterface_.mediaSourceEngine.isResetMediaSourceNecessary(
-              mediaState.type, mediaState.stream);
+              mediaState.type, mediaState.stream, mimeType, codecs);
       if (isResetMediaSourceNecessary) {
         let otherState = null;
         if (mediaState.type === ContentType.VIDEO) {
@@ -1739,9 +1733,16 @@ shaka.media.StreamingEngine = class {
           otherState = this.mediaStates_.get(ContentType.VIDEO);
         }
         if (otherState) {
+          // First, abort all operations in progress on the other stream.
+          await this.abortOperations_(otherState).catch(() => {});
+          // Then clear our cache of the last init segment, since MSE will be
+          // reloaded and no init segment will be there post-reload.
           otherState.lastInitSegmentReference = null;
+          // Now force the existing buffer to be cleared.  It is not necessary
+          // to perform the MSE clear operation, but this has the side-effect
+          // that our state for that stream will then match MSE's post-reload
+          // state.
           this.forceClearBuffer_(otherState);
-          this.abortOperations_(otherState).catch(() => {});
         }
       }
 
@@ -1772,19 +1773,6 @@ shaka.media.StreamingEngine = class {
               appendWindowEnd, ignoreTimestampOffset,
               reference.mimeType || mediaState.stream.mimeType,
               reference.codecs || mediaState.stream.codecs, streamsByType);
-          if (isResetMediaSourceNecessary) {
-            let otherState = null;
-            if (mediaState.type === ContentType.VIDEO) {
-              otherState = this.mediaStates_.get(ContentType.AUDIO);
-            } else if (mediaState.type === ContentType.AUDIO) {
-              otherState = this.mediaStates_.get(ContentType.VIDEO);
-            }
-            if (otherState) {
-              otherState.waitingToClearBuffer = false;
-              otherState.performingUpdate = false;
-              this.forceClearBuffer_(otherState);
-            }
-          }
         } catch (error) {
           mediaState.lastAppendWindowStart = null;
           mediaState.lastAppendWindowEnd = null;
@@ -1879,9 +1867,7 @@ shaka.media.StreamingEngine = class {
       // Across discontinuity bounds, we should resync timestamps for
       // sequence mode playbacks.  The next segment appended should
       // land at its theoretical timestamp from the segment index.
-      if (reference.discontinuitySequence != lastDiscontinuitySequence ||
-          mediaState.needsResync) {
-        mediaState.needsResync = false;
+      if (reference.discontinuitySequence != lastDiscontinuitySequence) {
         operations.push(this.playerInterface_.mediaSourceEngine.resync(
             mediaState.type, reference.startTime));
       }
@@ -2591,7 +2577,6 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   clearBufferSafeMargin: number,
  *   clearingBuffer: boolean,
  *   seeked: boolean,
- *   needsResync: boolean,
  *   adaptation: boolean,
  *   recovering: boolean,
  *   hasError: boolean,
@@ -2646,9 +2631,6 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   True indicates that the presentation just seeked.
  * @property {boolean} adaptation
  *   True indicates that the presentation just automatically switched variants.
- * @property {boolean} needsResync
- *   True indicates that the stream needs to be resynced in sequence mode,
- *   regardless of discontinuity sequence.
  * @property {boolean} recovering
  *   True indicates that the last segment was not appended because it could not
  *   fit in the buffer.

package/lib/mss/mss_parser.js

@@ -19,6 +19,7 @@ goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
+goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4Generator');
 goog.require('shaka.util.OperationManager');
 goog.require('shaka.util.Timer');
@@ -556,6 +557,7 @@ shaka.mss.MssParser = class {
       accessibilityPurpose: null,
       external: false,
       fastSwitching: false,
+      fullMimeTypes: new Set(),
     };
 
     // This is specifically for text tracks.
@@ -634,6 +636,8 @@ shaka.mss.MssParser = class {
         }
         break;
     }
+    stream.fullMimeTypes.add(shaka.util.MimeUtils.getFullType(
+        stream.mimeType, stream.codecs));
 
     // Lazy-Load the segment index to avoid create all init segment at the
     // same time

package/lib/offline/indexeddb/v1_storage_cell.js

@@ -211,6 +211,8 @@ shaka.offline.indexeddb.V1StorageCell = class
       appendWindowEnd,
       timestampOffset,
       tilesLayout: '',
+      mimeType: null,
+      codecs: null,
     };
   }
 

package/lib/offline/indexeddb/v2_storage_cell.js

@@ -155,6 +155,8 @@ shaka.offline.indexeddb.V2StorageCell = class
       timestampOffset,
       dataKey: old.dataKey,
       tilesLayout: '',
+      mimeType: null,
+      codecs: null,
     };
   }
 };

package/lib/offline/manifest_converter.js

@@ -14,6 +14,7 @@ goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.offline.OfflineUri');
 goog.require('shaka.util.ManifestParserUtils');
+goog.require('shaka.util.MimeUtils');
 
 
 /**
@@ -169,7 +170,7 @@ shaka.offline.ManifestConverter = class {
   fromStreamDB_(streamDB, timeline) {
     /** @type {!Array.<!shaka.media.SegmentReference>} */
     const segments = streamDB.segments.map(
-        (segment, index) => this.fromSegmentDB_(index, segment));
+        (segment, index) => this.fromSegmentDB_(index, segment, streamDB));
 
     timeline.notifySegments(segments);
 
@@ -212,6 +213,8 @@ shaka.offline.ManifestConverter = class {
       accessibilityPurpose: null,
       external: streamDB.external,
       fastSwitching: streamDB.fastSwitching,
+      fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+          streamDB.mimeType, streamDB.codecs)]),
     };
 
     return stream;
@@ -220,10 +223,11 @@ shaka.offline.ManifestConverter = class {
   /**
    * @param {number} index
    * @param {shaka.extern.SegmentDB} segmentDB
+   * @param {shaka.extern.StreamDB} streamDB
    * @return {!shaka.media.SegmentReference}
    * @private
    */
-  fromSegmentDB_(index, segmentDB) {
+  fromSegmentDB_(index, segmentDB, streamDB) {
     /** @type {!shaka.offline.OfflineUri} */
     const uri = shaka.offline.OfflineUri.segment(
         this.mechanism_, this.cell_, segmentDB.dataKey);
@@ -231,7 +235,7 @@ shaka.offline.ManifestConverter = class {
     const initSegmentReference = segmentDB.initSegmentKey != null ?
         this.fromInitSegmentDB_(segmentDB.initSegmentKey) : null;
 
-    return new shaka.media.SegmentReference(
+    const ref = new shaka.media.SegmentReference(
         segmentDB.startTime,
         segmentDB.endTime,
         () => [uri.toString()],
@@ -243,6 +247,9 @@ shaka.offline.ManifestConverter = class {
         segmentDB.appendWindowEnd,
         /* partialReferences= */ [],
         segmentDB.tilesLayout || '');
+    ref.mimeType = segmentDB.mimeType || streamDB.mimeType || '';
+    ref.codecs = segmentDB.codecs || streamDB.codecs || '';
+    return ref;
   }
 
   /**

package/lib/offline/storage.js

@@ -1389,6 +1389,8 @@ shaka.offline.Storage = class {
         tilesLayout: segment.tilesLayout,
         pendingSegmentRefId,
         dataKey: 0,
+        mimeType: segment.mimeType,
+        codecs: segment.codecs,
       };
       streamDb.segments.push(segmentDB);
       groupId = (groupId + 1) % numberOfParallelDownloads;

package/lib/player.js

@@ -1977,31 +1977,49 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.config_.playRangeStart,
         this.config_.playRangeEnd);
 
-    this.playhead_ = this.createPlayhead(this.startTime_);
-    this.playheadObservers_ =
-        this.createPlayheadObserversForMSE_(startTimeOfLoad);
 
-    // We need to start the buffer management code near the end because it
-    // will set the initial buffering state and that depends on other
-    // components being initialized.
-    const rebufferThreshold = Math.max(
-        this.manifest_.minBufferTime, this.config_.streaming.rebufferingGoal);
-    this.startBufferManagement_(mediaElement, rebufferThreshold);
+    const setupPlayhead = (startTime) => {
+      this.playhead_ = this.createPlayhead(startTime);
+      this.playheadObservers_ =
+          this.createPlayheadObserversForMSE_(startTimeOfLoad);
+
+      // We need to start the buffer management code near the end because it
+      // will set the initial buffering state and that depends on other
+      // components being initialized.
+      const rebufferThreshold = Math.max(
+          this.manifest_.minBufferTime,
+          this.config_.streaming.rebufferingGoal);
+      this.startBufferManagement_(mediaElement, rebufferThreshold);
+    };
+
+    if (!this.config_.streaming.startAtSegmentBoundary) {
+      setupPlayhead(this.startTime_);
+    }
 
     // Now we can switch to the initial variant.
     if (!activeVariant) {
       goog.asserts.assert(initialVariant,
           'Must have choosen an initial variant!');
 
-      this.switchVariant_(initialVariant, /* fromAdaptation= */ true,
-          /* clearBuffer= */ false, /* safeMargin= */ 0);
-
       // Now that we have initial streams, we may adjust the start time to
       // align to a segment boundary.
       if (this.config_.streaming.startAtSegmentBoundary) {
-        this.playhead_.setStartTime(await this.adjustStartTime_(
-            initialVariant, this.playhead_.getTime()));
+        const timeline = this.manifest_.presentationTimeline;
+        let initialTime = this.startTime_ || this.video_.currentTime;
+        const seekRangeStart = timeline.getSeekRangeStart();
+        const seekRangeEnd = timeline.getSeekRangeEnd();
+        if (initialTime < seekRangeStart) {
+          initialTime = seekRangeStart;
+        } else if (initialTime > seekRangeEnd) {
+          initialTime = seekRangeEnd;
+        }
+        const startTime = await this.adjustStartTime_(
+            initialVariant, initialTime);
+        setupPlayhead(startTime);
       }
+
+      this.switchVariant_(initialVariant, /* fromAdaptation= */ true,
+          /* clearBuffer= */ false, /* safeMargin= */ 0);
     }
 
     this.playhead_.ready();
@@ -2174,12 +2192,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         accessibilityPurpose: null,
         external: false,
         fastSwitching: false,
+        fullMimeTypes: new Set(),
       },
       bandwidth: 100,
       allowedByApplication: true,
       allowedByKeySystem: true,
       decodingInfos: [],
     };
+    variant.video.fullMimeTypes.add(shaka.util.MimeUtils.getFullType(
+        variant.video.mimeType, variant.video.codecs));
 
     this.drmEngine_.setSrcEquals(/* srcEquals= */ true);
     await this.drmEngine_.initForPlayback(
@@ -2313,6 +2334,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       mediaElement.load();
     }
 
+    // In Safari using HLS won't load anything unless you call load()
+    // explicitly, no matter the value of the preload attribute.
+    // Note: this only happens when there are not autoplay.
+    if (mediaElement.preload != 'none' && !mediaElement.autoplay &&
+        shaka.util.MimeUtils.isHlsType(mimeType) &&
+        shaka.util.Platform.safariVersion()) {
+      mediaElement.load();
+    }
+
     // Set the load mode last so that we know that all our components are
     // initialized.
     this.loadMode_ = shaka.Player.LoadMode.SRC_EQUALS;
@@ -3620,12 +3650,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         const currentTime = this.video_.currentTime;
         const seekRange = this.seekRange();
         const safeSeekOffset = this.config_.streaming.safeSeekOffset;
+
+        // Cancel trick play if we hit the beginning or end of the seekable
+        // (Sub-second accuracy not required here)
         if (rate > 0) {
-          if (currentTime >= seekRange.end) {
+          if (Math.floor(currentTime) >= Math.floor(seekRange.end)) {
             this.cancelTrickPlay();
           }
         } else {
-          if (currentTime <= (seekRange.start + safeSeekOffset)) {
+          if (Math.floor(currentTime) <=
+              Math.floor(seekRange.start + safeSeekOffset)) {
             this.cancelTrickPlay();
           }
         }
@@ -4804,6 +4838,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       accessibilityPurpose: null,
       external: true,
       fastSwitching: false,
+      fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+          mimeType || '', codec || '')]),
     };
 
     const fullMimeType = shaka.util.MimeUtils.getFullType(
@@ -4960,6 +4996,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       accessibilityPurpose: null,
       external: true,
       fastSwitching: false,
+      fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+          mimeType || '', '')]),
     };
 
     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
@@ -5390,6 +5428,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               accessibilityPurpose: null,
               external: false,
               fastSwitching: false,
+              fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+                  mimeType, '')]),
             };
             manifest.textStreams.push(textStream);
             closedCaptionsSet.add(id);
@@ -6947,7 +6987,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.7.12' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.7.14' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/text/ui_text_displayer.js

@@ -72,7 +72,9 @@ shaka.text.UITextDisplayer = class {
 
     /** @private {shaka.util.Timer} */
     this.captionsTimer_ = new shaka.util.Timer(() => {
-      this.updateCaptions_();
+      if (!this.video_.paused) {
+        this.updateCaptions_();
+      }
     }).tickEvery(updatePeriod);
 
     /**
@@ -93,6 +95,10 @@ shaka.text.UITextDisplayer = class {
       this.updateCaptions_(/* forceUpdate= */ true);
     });
 
+    this.eventManager_.listen(this.video_, 'seeking', () => {
+      this.updateCaptions_(/* forceUpdate= */ true);
+    });
+
     // From: https://html.spec.whatwg.org/multipage/media.html#dom-video-videowidth
     // Whenever the natural width or natural height of the video changes
     // (including, for example, because the selected video track was changed),
@@ -339,6 +345,9 @@ shaka.text.UITextDisplayer = class {
         const cueRegistry = this.currentCuesMap_.get(cue);
         goog.asserts.assert(cueRegistry, 'cueRegistry should exist.');
         if (cueRegistry.regionElement) {
+          if (cueRegistry.regionElement.contains(container)) {
+            cueRegistry.regionElement.removeChild(container);
+          }
           container.appendChild(cueRegistry.regionElement);
           cueRegistry.regionElement.appendChild(cueRegistry.cueElement);
         } else {

package/lib/util/mime_utils.js

@@ -84,17 +84,22 @@ shaka.util.MimeUtils = class {
    * beyond the container and codec type, when available.
    *
    * @param {shaka.extern.Stream} stream
+   * @param {string} mimeType
+   * @param {string} codecs
    * @return {string}
    */
-  static getExtendedType(stream) {
-    const components = [stream.mimeType];
+  static getExtendedType(stream, mimeType, codecs) {
+    const components = [mimeType];
 
     const extendedMimeParams = shaka.util.MimeUtils.EXTENDED_MIME_PARAMETERS_;
     extendedMimeParams.forEach((mimeKey, streamKey) => {
       const value = stream[streamKey];
-      if (streamKey == 'codecs' &&
-          shaka.util.MimeUtils.RAW_FORMATS.includes(stream.mimeType)) {
-        // Skip codecs for raw formats
+      if (streamKey == 'codecs') {
+        if (shaka.util.MimeUtils.RAW_FORMATS.includes(stream.mimeType)) {
+          // Skip codecs for raw formats
+        } else {
+          components.push('codecs="' + codecs + '"');
+        }
       } else if (value) {
         components.push(mimeKey + '="' + value + '"');
       }

package/lib/util/periods.js

@@ -599,14 +599,6 @@ shaka.util.PeriodCombiner = class {
         goog.asserts.assert(match.segmentIndex,
             'stream should have a segmentIndex.');
         if (match.segmentIndex) {
-          match.segmentIndex.forEachTopLevelReference((ref) => {
-            ref.codecs = match.codecs;
-            ref.mimeType = match.mimeType;
-            if (ref.initSegmentReference) {
-              ref.initSegmentReference.codecs = match.codecs;
-              ref.initSegmentReference.mimeType = match.mimeType;
-            }
-          });
           outputStream.segmentIndex.appendSegmentIndex(match.segmentIndex);
         }
       }
@@ -721,39 +713,14 @@ shaka.util.PeriodCombiner = class {
 
       if (used) {
         unusedStreamsPerPeriod[i].delete(match);
-        // Add the codec of this stream to the output stream's codecs.
-        const codecs = new Set(outputStream.codecs.split(','));
-        for (const codec of match.codecs.split(',')) {
-          if (codec) {
-            codecs.add(codec);
+        // Add the full mimetypes to the stream.
+        if (match.fullMimeTypes) {
+          for (const fullMimeType of match.fullMimeTypes.values()) {
+            outputStream.fullMimeTypes.add(fullMimeType);
           }
         }
-        const PeriodCombiner = shaka.util.PeriodCombiner;
-        outputStream.codecs = PeriodCombiner.filterDuplicateCodecs_(
-            Array.from(codecs)).join(',');
-      }
-    }
-  }
-
-  /**
-   * @param {!Array.<string>} codecs
-   * @return {!Array.<string>} codecs
-   * @private
-   */
-  static filterDuplicateCodecs_(codecs) {
-    // Filter out duplicate codecs.
-    const seen = new Set();
-    const ret = [];
-    for (const codec of codecs) {
-      const shortCodec = shaka.util.MimeUtils.getCodecBase(codec);
-      if (!seen.has(shortCodec)) {
-        ret.push(codec);
-        seen.add(shortCodec);
-      } else {
-        shaka.log.debug('Ignoring duplicate codec');
       }
     }
-    return ret;
   }
 
   /**
@@ -1578,6 +1545,7 @@ shaka.util.PeriodCombiner = class {
       accessibilityPurpose: null,
       external: false,
       fastSwitching: false,
+      fullMimeTypes: new Set(),
     };
   }
 

package/lib/util/platform.js

@@ -149,10 +149,9 @@ shaka.util.Platform = class {
    * @return {boolean}
    */
   static isWebOS3() {
-    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
-    return shaka.util.Platform.userAgentContains_('Web0S') &&
-        shaka.util.Platform.userAgentContains_(
-            'Chrome/38.0.2125.122 Safari/537.36');
+    // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
+    return shaka.util.Platform.isWebOS() &&
+        shaka.util.Platform.chromeVersion() === 38;
   }
 
   /**
@@ -161,18 +160,20 @@ shaka.util.Platform = class {
    * @return {boolean}
    */
   static isWebOS4() {
-    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
-    return !!navigator.userAgent.match(/webOS\/4/i);
+    // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
+    return shaka.util.Platform.isWebOS() &&
+        shaka.util.Platform.chromeVersion() === 53;
   }
 
   /**
-   * Check if the current platform is a WebOS 4.
+   * Check if the current platform is a WebOS 5.
    *
    * @return {boolean}
    */
   static isWebOS5() {
-    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
-    return !!navigator.userAgent.match(/webOS\/5/i);
+    // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
+    return shaka.util.Platform.isWebOS() &&
+        shaka.util.Platform.chromeVersion() === 68;
   }
 
   /**
@@ -184,6 +185,17 @@ shaka.util.Platform = class {
     return shaka.util.Platform.userAgentContains_('CrKey');
   }
 
+  /**
+   * Check if the current platform is a Google Chromecast with Android
+   * (i.e. Chromecast with GoogleTV).
+   *
+   * @return {boolean}
+   */
+  static isAndroidCastDevice() {
+    const Platform = shaka.util.Platform;
+    return Platform.isChromecast() && Platform.isAndroid();
+  }
+
   /**
    * Returns a major version number for Chrome, or Chromium-based browsers.
    *
@@ -414,6 +426,9 @@ shaka.util.Platform = class {
       return navigator.userAgentData.platform.toLowerCase() == 'macos';
     }
     // Fall back to the old API, with less strict matching.
+    if (!navigator.platform) {
+      return false;
+    }
     return navigator.platform.toLowerCase().includes('mac');
   }
 
@@ -428,6 +443,9 @@ shaka.util.Platform = class {
       return navigator.userAgentData.platform.toLowerCase() == 'windows';
     }
     // Fall back to the old API, with less strict matching.
+    if (!navigator.platform) {
+      return false;
+    }
     return navigator.platform.toLowerCase().includes('windows');
   }
 
@@ -535,6 +553,10 @@ shaka.util.Platform = class {
         Platform.isWebOS4() || Platform.isWebOS5()) {
       return false;
     }
+    // Older chromecasts without GoogleTV seem to not support SMOOTH properly.
+    if (Platform.isChromecast() && !Platform.isAndroidCastDevice()) {
+      return false;
+    }
     // See: https://chromium-review.googlesource.com/c/chromium/src/+/4577759
     if (Platform.isWindows() && Platform.isEdge()) {
       return false;