shaka-player 4.7.13 → 4.7.15

package/lib/media/streaming_engine.js

@@ -1733,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(() => {});
         }
       }
 
@@ -1766,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;

package/lib/net/http_fetch_plugin.js

@@ -167,8 +167,10 @@ shaka.net.HttpFetchPlugin = class {
             // is long enough, or if a whole segment is downloaded, call
             // progressUpdated().
             if (currentTime - lastTime > 100 || readObj.done) {
+              const numBytesRemaining =
+                  readObj.done ? 0 : contentLength - loaded;
               progressUpdated(currentTime - lastTime, loaded - lastLoaded,
-                  contentLength - loaded);
+                  numBytesRemaining);
               lastLoaded = loaded;
               lastTime = currentTime;
             }

package/lib/net/http_xhr_plugin.js

@@ -67,6 +67,9 @@ shaka.net.HttpXHRPlugin = class {
         const xhrResponse = xhr.response;
 
         try {
+          const currentTime = Date.now();
+          progressUpdated(currentTime - lastTime, event.loaded - lastLoaded,
+              /* numBytesRemaining= */ 0);
           const response = shaka.net.HttpPluginUtils.makeResponse(headers,
               xhrResponse, xhr.status, uri, xhr.responseURL, requestType);
           resolve(response);
@@ -97,8 +100,10 @@ shaka.net.HttpXHRPlugin = class {
         // progressUpdated().
         if (currentTime - lastTime > 100 ||
             (event.lengthComputable && event.loaded == event.total)) {
+          const numBytesRemaining =
+              xhr.readyState == 4 ? 0 : event.total - event.loaded;
           progressUpdated(currentTime - lastTime, event.loaded - lastLoaded,
-              event.total - event.loaded);
+              numBytesRemaining);
           lastLoaded = event.loaded;
           lastTime = currentTime;
         }

package/lib/player.js

@@ -596,6 +596,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;
 
@@ -1191,6 +1197,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_) {
@@ -1977,31 +1988,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_(startTime);
+
+      // 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();
@@ -2065,7 +2094,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.manifest_.serviceDescription)) {
       const onTimeUpdate = () => this.onTimeUpdate_();
       this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
-    } else if (!isLive) {
+    }
+    if (!isLive) {
       const onVideoProgress = () => this.onVideoProgress_();
       this.loadEventManager_.listen(
           mediaElement, 'timeupdate', onVideoProgress);
@@ -2147,42 +2177,49 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       disabledUntilTime: 0,
       primary: false,
       audio: null,
-      video: {
-        id: 0,
-        originalId: null,
-        groupId: null,
-        createSegmentIndex: () => Promise.resolve(),
-        segmentIndex: null,
-        mimeType: mimeType ? shaka.util.MimeUtils.getBasicType(mimeType) : '',
-        codecs: mimeType ? shaka.util.MimeUtils.getCodecs(mimeType) : '',
-        encrypted: true,
-        drmInfos: [],  // Filled in by DrmEngine config.
-        keyIds: new Set(),
-        language: 'und',
-        originalLanguage: null,
-        label: null,
-        type: ContentType.VIDEO,
-        primary: false,
-        trickModeVideo: null,
-        emsgSchemeIdUris: null,
-        roles: [],
-        forced: false,
-        channelsCount: null,
-        audioSamplingRate: null,
-        spatialAudio: false,
-        closedCaptions: null,
-        accessibilityPurpose: null,
-        external: false,
-        fastSwitching: false,
-        fullMimeTypes: new Set(),
-      },
+      video: null,
       bandwidth: 100,
       allowedByApplication: true,
       allowedByKeySystem: true,
       decodingInfos: [],
     };
-    variant.video.fullMimeTypes.add(shaka.util.MimeUtils.getFullType(
-        variant.video.mimeType, variant.video.codecs));
+    const stream = {
+      id: 0,
+      originalId: null,
+      groupId: null,
+      createSegmentIndex: () => Promise.resolve(),
+      segmentIndex: null,
+      mimeType: mimeType ? shaka.util.MimeUtils.getBasicType(mimeType) : '',
+      codecs: mimeType ? shaka.util.MimeUtils.getCodecs(mimeType) : '',
+      encrypted: true,
+      drmInfos: [],  // Filled in by DrmEngine config.
+      keyIds: new Set(),
+      language: 'und',
+      originalLanguage: null,
+      label: null,
+      type: ContentType.VIDEO,
+      primary: false,
+      trickModeVideo: null,
+      emsgSchemeIdUris: null,
+      roles: [],
+      forced: false,
+      channelsCount: null,
+      audioSamplingRate: null,
+      spatialAudio: false,
+      closedCaptions: null,
+      accessibilityPurpose: null,
+      external: false,
+      fastSwitching: false,
+      fullMimeTypes: new Set(),
+    };
+    stream.fullMimeTypes.add(shaka.util.MimeUtils.getFullType(
+        stream.mimeType, stream.codecs));
+    if (mimeType.startsWith('audio/')) {
+      stream.type = ContentType.AUDIO;
+      variant.audio = stream;
+    } else {
+      variant.video = stream;
+    }
 
     this.drmEngine_.setSrcEquals(/* srcEquals= */ true);
     await this.drmEngine_.initForPlayback(
@@ -2316,6 +2353,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;
@@ -2399,7 +2445,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (isLive && this.config_.streaming.liveSync) {
       const onTimeUpdate = () => this.onTimeUpdate_();
       this.loadEventManager_.listen(mediaElement, 'timeupdate', onTimeUpdate);
-    } else if (!isLive) {
+    }
+    if (!isLive) {
       const onVideoProgress = () => this.onVideoProgress_();
       this.loadEventManager_.listen(
           mediaElement, 'timeupdate', onVideoProgress);
@@ -2717,16 +2764,16 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * Create the observers for MSE playback. These observers are responsible for
    * notifying the app and player of specific events during MSE playback.
    *
-   * @param {number} startTimeOfLoad
+   * @param {number} startTime
    * @return {!shaka.media.PlayheadObserverManager}
    * @private
    */
-  createPlayheadObserversForMSE_(startTimeOfLoad) {
+  createPlayheadObserversForMSE_(startTime) {
     goog.asserts.assert(this.manifest_, 'Must have manifest');
     goog.asserts.assert(this.regionTimeline_, 'Must have region timeline');
     goog.asserts.assert(this.video_, 'Must have video element');
 
-    const startsPastZero = this.isLive() || startTimeOfLoad > 0;
+    const startsPastZero = this.isLive() || startTime > 0;
 
     // Create the region observer. This will allow us to notify the app when we
     // move in and out of timeline regions.
@@ -2784,6 +2831,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);
 
@@ -2793,6 +2844,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',
@@ -5556,6 +5610,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);
       }
@@ -6151,8 +6206,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     shaka.log.debug('switch_');
     goog.asserts.assert(this.config_.abr.enabled,
         'AbrManager should not call switch while disabled!');
-    goog.asserts.assert(this.manifest_, 'We need a manifest to switch ' +
-                                        'variants.');
+
+    if (!this.manifest_) {
+      // It could come from a preload manager operation.
+      return;
+    }
 
     if (!this.streamingEngine_) {
       // There's no way to change it.
@@ -6960,7 +7018,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.7.13' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.7.15' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/media_capabilities.js

@@ -25,10 +25,8 @@ shaka.polyfill.MediaCapabilities = class {
    * @export
    */
   static install() {
-    // 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.
+    // We can enable MediaCapabilities in Android and Fuchsia devices, but not
+    // in Linux devices because the implementation is buggy.
     // Since MediaCapabilities implementation is buggy in Apple browsers, we
     // should always install polyfill for Apple browsers.
     // See: https://github.com/shaka-project/shaka-player/issues/3530
@@ -50,12 +48,16 @@ shaka.polyfill.MediaCapabilities = class {
     // Since MediaCapabilities implementation is buggy in Hisense browsers, we
     // should always install polyfill for Hisense browsers.
     let canUseNativeMCap = true;
+    if (shaka.util.Platform.isChromecast() &&
+        !shaka.util.Platform.isAndroidCastDevice() &&
+        !shaka.util.Platform.isFuchsiaCastDevice()) {
+      canUseNativeMCap = false;
+    }
     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.isEOS() ||
         shaka.util.Platform.isHisense()) {
       canUseNativeMCap = false;

package/lib/polyfill/patchedmediakeys_cert.js

@@ -0,0 +1,62 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.polyfill.PatchedMediaKeysCert');
+
+goog.require('shaka.log');
+goog.require('shaka.polyfill');
+goog.require('shaka.util.Platform');
+
+
+/**
+ * @summary A polyfill to fix setServerCertificate implementation on
+ * older platforms which claim to support modern EME.
+ * @export
+ */
+shaka.polyfill.PatchedMediaKeysCert = class {
+  /**
+   * Installs the polyfill if needed.
+   * @export
+   */
+  static install() {
+    if (!window.MediaKeys) {
+      // No MediaKeys available
+      return;
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    if (MediaKeys.prototype.setServerCertificate &&
+        !shaka.polyfill.PatchedMediaKeysCert.hasInvalidImplementation_()) {
+      // setServerCertificate is there and userAgent seems to be valid.
+      return;
+    }
+
+    shaka.log.info('Patching MediaKeys.setServerCertificate');
+    // eslint-disable-next-line no-restricted-syntax
+    MediaKeys.prototype.setServerCertificate =
+      shaka.polyfill.PatchedMediaKeysCert.setServerCertificate_;
+  }
+
+  /**
+   * @param {!BufferSource} certificate
+   * @return {!Promise<boolean>}
+   * @private
+   */
+  static setServerCertificate_(certificate) {
+    shaka.log.debug('PatchedMediaKeysCert.setServerCertificate');
+    return Promise.resolve(false);
+  }
+
+  /**
+   * @return {boolean}
+   * @private
+   */
+  static hasInvalidImplementation_() {
+    return shaka.util.Platform.isTizen3() || shaka.util.Platform.isTizen4() ||
+      shaka.util.Platform.isTizen5_0() || shaka.util.Platform.isWebOS3();
+  }
+};
+
+shaka.polyfill.register(shaka.polyfill.PatchedMediaKeysCert.install);

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/transmuxer/ts_transmuxer.js

@@ -21,6 +21,7 @@ goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4Generator');
+goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.TsParser');
 goog.require('shaka.util.Uint8ArrayUtils');
 
@@ -142,13 +143,17 @@ shaka.transmuxer.TsTransmuxer = class {
   convertCodecs(contentType, mimeType) {
     if (this.isTsContainer_(mimeType)) {
       const ContentType = shaka.util.ManifestParserUtils.ContentType;
+      const StreamUtils = shaka.util.StreamUtils;
       // The replace it's necessary because Firefox(the only browser that
       // supports MP3 in MP4) only support the MP3 codec with the mp3 string.
       // MediaSource.isTypeSupported('audio/mp4; codecs="mp4a.40.34"') -> false
       // MediaSource.isTypeSupported('audio/mp4; codecs="mp3"') -> true
       const codecs = shaka.util.MimeUtils.getCodecs(mimeType)
           .replace('mp4a.40.34', 'mp3').split(',')
-          .map(this.getCorrectVideoCodecs_).join(',');
+          .map((codecs) => {
+            return StreamUtils.getCorrectAudioCodecs(codecs, 'audio/mp4');
+          })
+          .map(StreamUtils.getCorrectVideoCodecs).join(',');
       if (contentType == ContentType.AUDIO) {
         return `audio/mp4; codecs="${codecs}"`;
       }
@@ -158,29 +163,6 @@ shaka.transmuxer.TsTransmuxer = class {
   }
 
 
-  /**
-   * @param {string} codec
-   * @return {string}
-   * @private
-   */
-  getCorrectVideoCodecs_(codec) {
-    if (codec.includes('avc1')) {
-      // Convert avc1 codec string from RFC-4281 to RFC-6381 for
-      // MediaSource.isTypeSupported
-      // Example, convert avc1.66.30 to avc1.42001e (0x42 == 66 and 0x1e == 30)
-      const avcdata = codec.split('.');
-      if (avcdata.length == 3) {
-        let result = avcdata.shift() + '.';
-        result += parseInt(avcdata.shift(), 10).toString(16);
-        result +=
-            ('000' + parseInt(avcdata.shift(), 10).toString(16)).slice(-4);
-        return result;
-      }
-    }
-    return codec;
-  }
-
-
   /**
    * @override
    * @export

package/lib/util/object_utils.js

@@ -41,8 +41,7 @@ shaka.util.ObjectUtils = class {
 
           // This covers Uint8Array and friends, even without a TypedArray
           // base-class constructor.
-          const isTypedArray =
-              val.buffer && val.buffer.constructor == ArrayBuffer;
+          const isTypedArray = val.buffer instanceof ArrayBuffer;
           if (isTypedArray) {
             return val;
           }