shaka-player 4.8.1 → 4.8.3

package/externs/shaka/player.js

@@ -1519,11 +1519,14 @@ shaka.extern.AdsConfiguration;
  * @property {boolean} enabled
  *   If true, enable adaptation by the current AbrManager.  Defaults to true.
  * @property {boolean} useNetworkInformation
- *   If true, use Network Information API in the current AbrManager.
+ *   If true, use the Network Information API in the current AbrManager, if it
+ *   is available in the browser environment.  If the Network Information API is
+ *   used, Shaka Player will ignore the defaultBandwidthEstimate config.
  *   Defaults to true.
  * @property {number} defaultBandwidthEstimate
  *   The default bandwidth estimate to use if there is not enough data, in
- *   bit/sec.
+ *   bit/sec.  Only used if useNetworkInformation is false, or if the Network
+ *   Information API is not available.
  * @property {shaka.extern.Restrictions} restrictions
  *   The restrictions to apply to ABR decisions.  These are "soft" restrictions.
  *   Any track that fails to meet these restrictions will not be selected

package/lib/dash/mpd_utils.js

@@ -282,12 +282,6 @@ shaka.dash.MpdUtils = class {
     const durationStr =
         MpdUtils.inheritAttribute(context, callback, 'duration');
     let segmentDuration = TXml.parsePositiveInt(durationStr || '');
-    const ContentType = shaka.util.ManifestParserUtils.ContentType;
-    // TODO: The specification is not clear, check this once it is resolved:
-    // https://github.com/Dash-Industry-Forum/DASH-IF-IOP/issues/404
-    if (context.representation.contentType == ContentType.IMAGE) {
-      segmentDuration = TXml.parseFloat(durationStr || '');
-    }
     if (segmentDuration) {
       segmentDuration /= timescale;
     }

package/lib/dash/segment_template.js

@@ -398,6 +398,11 @@ shaka.dash.SegmentTemplate = class {
         Math.ceil(availablePeriodTimes[1] / segmentDuration) - 1,
       ];
 
+      // For Low Latency we can request the partial current position.
+      if (context.representation.availabilityTimeOffset) {
+        availablePeriodPositions[1]++;
+      }
+
       // In absolute positions.
       const availablePresentationPositions =
           availablePeriodPositions.map((x) => x + startNumber);

package/lib/media/play_rate_controller.js

@@ -6,6 +6,7 @@
 
 goog.provide('shaka.media.PlayRateController');
 
+goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.Timer');
@@ -27,6 +28,9 @@ shaka.media.PlayRateController = class {
     /** @private {?shaka.media.PlayRateController.Harness} */
     this.harness_ = harness;
 
+    /** @private {boolean} */
+    this.isBuffering_ = false;
+
     /** @private {number} */
     this.rate_ = this.harness_.getRate();
 
@@ -51,15 +55,25 @@ shaka.media.PlayRateController = class {
   }
 
   /**
-   * Set the playback rate.
+   * Sets the buffering flag, which controls the effective playback rate.
+   *
+   * @param {boolean} isBuffering If true, forces playback rate to 0 internally.
+   */
+  setBuffering(isBuffering) {
+    this.isBuffering_ = isBuffering;
+    this.apply_();
+  }
+
+  /**
+   * Set the playback rate. This rate will only be used as provided when the
+   * player is not buffering. You should never set the rate to 0.
    *
    * @param {number} rate
    */
   set(rate) {
-    if (this.rate_ != rate) {
-      this.rate_ = rate;
-      this.apply_();
-    }
+    goog.asserts.assert(rate != 0, 'Should never set rate of 0 explicitly!');
+    this.rate_ = rate;
+    this.apply_();
   }
 
   /**
@@ -93,11 +107,14 @@ shaka.media.PlayRateController = class {
     // Always stop the timer. We may not start it again.
     this.timer_.stop();
 
-    shaka.log.v1('Changing effective playback rate to', this.rate_);
+    /** @type {number} */
+    const rate = this.calculateCurrentRate_();
+
+    shaka.log.v1('Changing effective playback rate to', rate);
 
-    if (this.rate_ >= 0) {
+    if (rate >= 0) {
       try {
-        this.applyRate_(this.rate_);
+        this.applyRate_(rate);
         return;
       } catch (e) {
         // Fall through to the next clause.
@@ -117,6 +134,17 @@ shaka.media.PlayRateController = class {
     this.applyRate_(0);
   }
 
+  /**
+   * Calculate the rate that the controller wants the media element to have
+   * based on the current state of the controller.
+   *
+   * @return {number}
+   * @private
+   */
+  calculateCurrentRate_() {
+    return this.isBuffering_ ? 0 : this.rate_;
+  }
+
   /**
    * If the new rate is different than the media element's playback rate, this
    * will change the playback rate. If the rate does not need to change, it will

package/lib/media/playhead.js

@@ -382,10 +382,10 @@ shaka.media.MediaSourcePlayhead = class {
       seekStart = seekEnd - this.minSeekRange_;
     }
 
-    if (currentTime < seekStart || currentTime > seekEnd) {
-      // playhead is outside of the seekrange.  Move playhead to catch up.
+    if (currentTime < seekStart) {
+      // The seek range has moved past the playhead.  Move ahead to catch up.
       const targetTime = this.reposition_(currentTime);
-      shaka.log.info('Jumping by ' + (targetTime - currentTime) +
+      shaka.log.info('Jumping forward ' + (targetTime - currentTime) +
                      ' seconds to catch up with the seek range.');
       this.mediaElement_.currentTime = targetTime;
     }

package/lib/media/segment_prefetch.js

@@ -147,7 +147,12 @@ shaka.media.SegmentPrefetch = class {
     }
 
     // init segments are ignored from the prefetch limit
-    if (!this.initSegmentPrefetchMap_.has(initSegmentReference)) {
+    const initSegments = Array.from(this.initSegmentPrefetchMap_.keys());
+    const someReference = initSegments.some((reference) => {
+      return shaka.media.InitSegmentReference.equal(
+          reference, initSegmentReference);
+    });
+    if (!someReference) {
       const segmentPrefetchOperation =
         new shaka.media.SegmentPrefetchOperation(this.fetchDispatcher_);
       segmentPrefetchOperation.dispatchFetch(
@@ -233,6 +238,15 @@ shaka.media.SegmentPrefetch = class {
     this.prefetchPosTime_ = 0;
   }
 
+  /**
+   * Remove a reference of prefetched segment if already exists.
+   * @param {!shaka.media.SegmentReference} reference
+   * @public
+   */
+  removeReference(reference) {
+    this.abortPrefetchedSegment_(reference);
+  }
+
   /**
    * @param {number} time
    * @param {boolean=} clearInitSegments
@@ -261,9 +275,11 @@ shaka.media.SegmentPrefetch = class {
     const segmentReferences = Array.from(this.segmentPrefetchMap_.keys());
     for (const initSegmentReference of this.initSegmentPrefetchMap_.keys()) {
       // if no segment references this init segment, we should remove it.
-      if (!segmentReferences.some(
-          (segmentReference) =>
-            segmentReference.initSegmentReference === initSegmentReference)) {
+      const someReference = segmentReferences.some((segmentReference) => {
+        return shaka.media.InitSegmentReference.equal(
+            segmentReference.initSegmentReference, initSegmentReference);
+      });
+      if (!someReference) {
         this.abortPrefetchedSegment_(initSegmentReference);
       }
     }

package/lib/media/stall_detector.js

@@ -174,6 +174,9 @@ shaka.media.StallDetector.MediaElementImplementation = class {
     if (this.mediaElement_.paused) {
       return false;
     }
+    if (this.mediaElement_.playbackRate == 0) {
+      return false;
+    }
 
     // If we have don't have enough content, we are not stalled, we are
     // buffering.

package/lib/media/streaming_engine.js

@@ -1702,6 +1702,11 @@ shaka.media.StreamingEngine = class {
             error.code);
         mediaState.hasError = true;
 
+        if (error.category == shaka.util.Error.Category.NETWORK &&
+            mediaState.segmentPrefetch) {
+          mediaState.segmentPrefetch.removeReference(reference);
+        }
+
         error.severity = shaka.util.Error.Severity.CRITICAL;
         await this.handleStreamingError_(mediaState, error);
       }

package/lib/player.js

@@ -622,6 +622,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
      */
     this.playRateController_ = null;
 
+    // We use the buffering observer and timer to track when we move from having
+    // enough buffered content to not enough. They only exist when content has
+    // been loaded and are not re-used between loads.
+    /** @private {shaka.util.Timer} */
+    this.bufferPoller_ = null;
+
     /** @private {shaka.media.BufferingObserver} */
     this.bufferObserver_ = null;
 
@@ -1228,6 +1234,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.playheadObservers_ = null;
       }
 
+      if (this.bufferPoller_) {
+        this.bufferPoller_.stop();
+        this.bufferPoller_ = null;
+      }
+
       // Stop the parser early. Since it is at the start of the pipeline, it
       // should be start early to avoid is pushing new data downstream.
       if (this.parser_) {
@@ -3101,6 +3112,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         !this.bufferObserver_,
         'No buffering observer should exist before initialization.');
 
+    goog.asserts.assert(
+        !this.bufferPoller_,
+        'No buffer timer should exist before initialization.');
+
     // Give dummy values, will be updated below.
     this.bufferObserver_ = new shaka.media.BufferingObserver(1, 2);
 
@@ -3110,6 +3125,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.updateBufferingSettings_(rebufferingGoal);
     this.updateBufferState_();
 
+    this.bufferPoller_ = new shaka.util.Timer(() => {
+      this.pollBufferState_();
+    }).tickEvery(/* seconds= */ 0.25);
     this.loadEventManager_.listen(mediaElement, 'waiting',
         (e) => this.pollBufferState_());
     this.loadEventManager_.listen(mediaElement, 'stalled',
@@ -5833,6 +5851,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const loaded = this.stats_ && this.bufferObserver_ && this.playhead_;
 
     if (loaded) {
+      this.playRateController_.setBuffering(isBuffering);
       if (this.cmcdManager_) {
         this.cmcdManager_.setBuffering(isBuffering);
       }
@@ -7182,7 +7201,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.8.1' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.8.3' + '-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

@@ -8,6 +8,7 @@
 goog.provide('shaka.text.UITextDisplayer');
 
 goog.require('goog.asserts');
+goog.require('shaka.Deprecate');
 goog.require('shaka.text.Cue');
 goog.require('shaka.text.CueRegion');
 goog.require('shaka.util.Dom');
@@ -65,12 +66,22 @@ shaka.text.UITextDisplayer = class {
 
     this.videoContainer_.appendChild(this.textContainer_);
 
+    if (!config || !config.captionsUpdatePeriod) {
+      shaka.Deprecate.deprecateFeature(5,
+          'UITextDisplayer w/ config',
+          'Please migrate to initializing UITextDisplayer with a config.');
+    }
+
+    /** @private {number} */
+    const updatePeriod = (config && config.captionsUpdatePeriod) ?
+       config.captionsUpdatePeriod : 0.25;
+
     /** @private {shaka.util.Timer} */
     this.captionsTimer_ = new shaka.util.Timer(() => {
       if (!this.video_.paused) {
         this.updateCaptions_();
       }
-    }).tickEvery(config.captionsUpdatePeriod);
+    }).tickEvery(updatePeriod);
 
     /**
      * Maps cues to cue elements. Specifically points out the wrapper element of

package/lib/util/platform.js

@@ -186,6 +186,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.
    *
@@ -416,6 +427,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');
   }
 
@@ -430,6 +444,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');
   }
 
@@ -556,6 +573,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;
@@ -663,8 +684,8 @@ shaka.util.Platform = class {
         /** @type {{screenWidth: number, screenHeight: number}} */(
             JSON.parse(window.PalmSystem.deviceInfo));
         // WebOS has always been able to do 1080p.  Assume a 1080p limit.
-        maxResolution.width = Math.max(1920, deviceInfo.screenWidth);
-        maxResolution.height = Math.max(1080, deviceInfo.screenHeight);
+        maxResolution.width = Math.max(1920, deviceInfo['screenWidth']);
+        maxResolution.height = Math.max(1080, deviceInfo['screenHeight']);
       } catch (e) {
         shaka.log.alwaysWarn('WebOS: Error detecting screen size, default ' +
             'screen size 1920x1080.');

package/lib/util/tXml.js

@@ -779,7 +779,7 @@ shaka.util.TXml = class {
       element.setAttribute(k, v);
     }
 
-    if (doParents && node.parent) {
+    if (doParents && node.parent && node.parent.tagName != '?xml') {
       const parentElement = TXml.txmlNodeToDomElement(
           node.parent, /* doParents= */ true, /* doChildren= */ false);
       parentElement.appendChild(element);

package/package.json

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

package/ui/resolution_selection.js

@@ -116,6 +116,7 @@ shaka.ui.ResolutionSelection = class extends shaka.ui.SettingsMenu {
       } else {
         otherIdx = tracks.findIndex((t) => {
           return t.height == track.height &&
+              t.videoBandwidth == track.videoBandwidth &&
               t.frameRate == track.frameRate &&
               t.hdr == track.hdr &&
               t.videoLayout == track.videoLayout;