shaka-player 3.2.1 → 3.3.1

package/lib/offline/stored_content_utils.js

@@ -47,6 +47,7 @@ shaka.offline.StoredContentUtils = class {
       expiration: Infinity,
       tracks: tracks,
       appMetadata: metadata,
+      isIncomplete: false,
     };
 
     return content;
@@ -87,6 +88,7 @@ shaka.offline.StoredContentUtils = class {
       expiration: manifestDB.expiration,
       tracks: tracks,
       appMetadata: metadata,
+      isIncomplete: (manifestDB.isIncomplete || false),
     };
 
     return content;

package/lib/player.js

@@ -22,6 +22,7 @@ goog.require('shaka.media.PlayRateController');
 goog.require('shaka.media.Playhead');
 goog.require('shaka.media.PlayheadObserverManager');
 goog.require('shaka.media.PreferenceBasedCriteria');
+goog.require('shaka.media.QualityObserver');
 goog.require('shaka.media.RegionObserver');
 goog.require('shaka.media.RegionTimeline');
 goog.require('shaka.media.SegmentIndex');
@@ -36,6 +37,7 @@ goog.require('shaka.text.UITextDisplayer');
 goog.require('shaka.text.WebVttGenerator');
 goog.require('shaka.util.AbortableOperation');
 goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.CmcdManager');
 goog.require('shaka.util.ConfigUtils');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
@@ -106,6 +108,32 @@ goog.requireType('shaka.routing.Payload');
  */
 
 
+/**
+ * @event shaka.Player.DownloadFailed
+ * @description Fired when a download has failed, for any reason.
+ *   'downloadfailed'
+ * @property {!shaka.extern.Request} request
+ * @property {?shaka.util.Error} error
+ * @param {number} httpResponseCode
+ * @param {boolean} aborted
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.DownloadHeadersReceived
+ * @description Fired when the networking engine has received the headers for
+ *    a download, but before the body has been downloaded.
+ *    If the HTTP plugin being used does not track this information, this event
+ *    will default to being fired when the body is received, instead.
+ * @property {!Object.<string, string>} headers
+ * @property {!shaka.extern.Request} request
+ * @property {!shaka.net.NetworkingEngine.RequestType} type
+ *   'downloadheadersreceived'
+ * @exportDoc
+ */
+
+
 /**
  * @event shaka.Player.DrmSessionUpdateEvent
  * @description Fired when the CDM has accepted the license response.
@@ -147,6 +175,21 @@ goog.requireType('shaka.routing.Payload');
  * @exportDoc
  */
 
+/**
+ * @event shaka.Player.MediaQualityChangedEvent
+ * @description Fired when the media quality changes at the playhead.
+ * That may be caused by an adaptation change or a DASH period transition.
+ * Separate events are emitted for audio and video contentTypes.
+ * This is supported for only DASH streams at this time.
+ * @property {string} type
+ *   'mediaqualitychanged'
+ * @property {shaka.extern.MediaQualityInfo} mediaQuality
+ *   Information about media quality at the playhead position.
+ * @property {number} position
+ *   The playhead position.
+ * @exportDoc
+ */
+
 
 /**
  * @event shaka.Player.BufferingEvent
@@ -441,6 +484,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {shaka.media.RegionTimeline} */
     this.regionTimeline_ = null;
 
+    /** @private {shaka.util.CmcdManager} */
+    this.cmcdManager_ = null;
+
+    /** @private {shaka.media.QualityObserver} */
+    this.qualityObserver_ = null;
+
     /** @private {shaka.media.StreamingEngine} */
     this.streamingEngine_ = null;
 
@@ -507,6 +556,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {!Array.<function():(!Promise|undefined)>} */
     this.cleanupOnUnload_ = [];
 
+    /**
+     * This playback start position will be used when
+     * <code>updateStartTime()</code> has been called to provide an updated
+     * start position during the media loading process.
+     *
+     * @private {?number}
+     */
+    this.updatedStartTime_ = null;
+
     if (dependencyInjector) {
       dependencyInjector(this);
     }
@@ -598,7 +656,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       enterNode: (node, has, wants) => {
         this.dispatchEvent(this.makeEvent_(
             /* name= */ shaka.Player.EventName.OnStateChange,
-            /* data= */ {'state': node.name}));
+            /* data= */ (new Map()).set('state', node.name)));
 
         const action = actions.get(node);
         return action(has, wants);
@@ -629,7 +687,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       onIdle: (node) => {
         this.dispatchEvent(this.makeEvent_(
             /* name= */ shaka.Player.EventName.OnStateIdle,
-            /* data= */ {'state': node.name}));
+            /* data= */ (new Map()).set('state', node.name)));
       },
     };
 
@@ -649,7 +707,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
   /**
    * @param {!shaka.Player.EventName} name
-   * @param {Object=} data
+   * @param {Map.<string, Object>=} data
    * @return {!shaka.util.FakeEvent}
    * @private
    */
@@ -723,6 +781,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.config_ = null;
     this.stats_ = null;
     this.videoContainer_ = null;
+    this.cmcdManager_ = null;
 
     if (this.networkingEngine_) {
       await this.networkingEngine_.destroy();
@@ -1020,6 +1079,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return this.wrapWalkerListenersWithPromise_(events);
   }
 
+  /**
+   * Provides a way to update the stream start position during the media loading
+   * process. Can for example be called from the <code>manifestparsed</code>
+   * event handler to update the start position based on information in the
+   * manifest.
+   *
+   * @param {number} startTime
+   * @export
+   */
+  updateStartTime(startTime) {
+    this.updatedStartTime_ = startTime;
+  }
+
   /**
    * Tell the player to load the content at <code>assetUri</code> and start
    * playback at <code>startTime</code>. Before calling <code>load</code>,
@@ -1040,6 +1112,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @export
    */
   load(assetUri, startTime, mimeType) {
+    this.updatedStartTime_ = null;
+
     // Do not allow the player to be used after |destroy| is called.
     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
       return Promise.reject(this.createAbortLoadError_());
@@ -1093,6 +1167,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // before we allow calls to |updateStateHistory|.
     this.stats_ = new shaka.util.Stats();
 
+    // Create the CMCD manager so client data can be attached to all requests
+    this.cmcdManager_ = this.createCmcd_();
+
     // Load's request is a little different, so we can't use our normal
     // listeners-to-promise method. It is the only request where we may skip the
     // request, so we need to set the on skip callback to reject with a specific
@@ -1594,6 +1671,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     goog.asserts.assert(
         this.networkingEngine_,
         'Need networking engine to parse manifest.');
+    goog.asserts.assert(
+        this.cmcdManager_,
+        'Need CMCD manager to populate manifest request data.');
     goog.asserts.assert(
         this.config_,
         'Need player config to parse manifest.');
@@ -1617,9 +1697,23 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.adManager_.onDashTimedMetadata(region);
       }
     });
+    this.qualityObserver_ = null;
+    if (this.config_.streaming.observeQualityChanges) {
+      this.qualityObserver_ = new shaka.media.QualityObserver(
+          () => this.getBufferedInfo());
+      this.qualityObserver_.setListeners((mediaQualityInfo, position) => {
+        this.onMediaQualityChange_(mediaQualityInfo, position);
+      });
+    }
 
     const playerInterface = {
       networkingEngine: networkingEngine,
+      modifyManifestRequest: (request, manifestInfo) => {
+        this.cmcdManager_.applyManifestData(request, manifestInfo);
+      },
+      modifySegmentRequest: (request, segmentInfo) => {
+        this.cmcdManager_.applySegmentData(request, segmentInfo);
+      },
       filter: (manifest) => this.filterManifest_(manifest),
       makeTextStreamsForClosedCaptions: (manifest) => {
         return this.makeTextStreamsForClosedCaptions_(manifest);
@@ -1780,6 +1874,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // something we are now depending on.
     has.startTime = wants.startTime;
 
+    // If updateStartTime() has been called since load() was invoked use the
+    // requested startTime
+    if (this.updatedStartTime_ != null) {
+      has.startTime = this.updatedStartTime_;
+      this.updatedStartTime_ = null;
+    }
+
     // Store a reference to values in |has| after asserting so that closure will
     // know that they will still be non-null between calls to await.
     const mediaElement = has.mediaElement;
@@ -2177,9 +2278,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           this.video_.textTracks, 'change', () => this.onTracksChanged_());
     }
 
+    const extension = shaka.media.ManifestParser.getExtension(has.uri);
+    const mimeType =
+      shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_[extension];
+
     // By setting |src| we are done "loading" with src=. We don't need to set
     // the current time because |playhead| will do that for us.
-    has.mediaElement.src = has.uri;
+    has.mediaElement.src = this.cmcdManager_.appendSrcData(has.uri, mimeType);
 
     // Tizen 3 / WebOS won't load anything unless you call load() explicitly,
     // no matter the value of the preload attribute.  This is harmful on some
@@ -2417,12 +2522,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     goog.asserts.assert(!endTime || startTime <= endTime,
         'Metadata start time should be less or equal to the end time!');
     const eventName = shaka.Player.EventName.Metadata;
-    const data = {
-      startTime: startTime,
-      endTime: endTime,
-      metadataType: metadataType,
-      payload: payload,
-    };
+    const data = new Map()
+        .set('startTime', startTime)
+        .set('endTime', endTime)
+        .set('metadataType', metadataType)
+        .set('payload', payload);
     this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
@@ -2510,8 +2614,30 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.abrManager_.segmentDownloaded(deltaTimeMs, bytesDownloaded);
       }
     };
+    /** @type {shaka.net.NetworkingEngine.OnHeadersReceived} */
+    const onHeadersReceived_ = (headers, request, requestType) => {
+      // Release a 'downloadheadersreceived' event.
+      const name = shaka.Player.EventName.DownloadHeadersReceived;
+      const data = new Map()
+          .set('headers', headers)
+          .set('request', request)
+          .set('requestType', requestType);
+      this.dispatchEvent(this.makeEvent_(name, data));
+    };
+    /** @type {shaka.net.NetworkingEngine.OnDownloadFailed} */
+    const onDownloadFailed_ = (request, error, httpResponseCode, aborted) => {
+      // Release a 'downloadfailed' event.
+      const name = shaka.Player.EventName.DownloadFailed;
+      const data = new Map()
+          .set('request', request)
+          .set('error', error)
+          .set('httpResponseCode', httpResponseCode)
+          .set('aborted', aborted);
+      this.dispatchEvent(this.makeEvent_(name, data));
+    };
 
-    return new shaka.net.NetworkingEngine(onProgressUpdated_);
+    return new shaka.net.NetworkingEngine(
+        onProgressUpdated_, onHeadersReceived_, onDownloadFailed_);
   }
 
   /**
@@ -2567,7 +2693,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Now that we have all our observers, create a manager for them.
     const manager = new shaka.media.PlayheadObserverManager(this.video_);
     manager.manage(regionObserver);
-
+    if (this.qualityObserver_) {
+      manager.manage(this.qualityObserver_);
+    }
     return manager;
   }
 
@@ -2683,6 +2811,26 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         mediaElement, closedCaptionsParser, textDisplayer, onMetadata);
   }
 
+  /**
+   * Create a new CMCD manager.
+   *
+   * @private
+   */
+  createCmcd_() {
+    /** @type {shaka.util.CmcdManager.PlayerInterface} */
+    const playerInterface = {
+      getBandwidthEstimate: () => this.abrManager_ ?
+        this.abrManager_.getBandwidthEstimate() : NaN,
+      getBufferedInfo: () => this.getBufferedInfo(),
+      getCurrentTime: () => this.video_ ? this.video_.currentTime : 0,
+      getVariantTracks: () => this.getVariantTracks(),
+      getPlaybackRate: () => this.getPlaybackRate(),
+      isLive: () => this.isLive(),
+    };
+
+    return new shaka.util.CmcdManager(playerInterface, this.config_.cmcd);
+  }
+
   /**
    * Creates a new instance of StreamingEngine.  This can be replaced by tests
    * to create fake instances instead.
@@ -2692,19 +2840,28 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   createStreamingEngine() {
     goog.asserts.assert(
         this.playhead_ && this.abrManager_ && this.mediaSourceEngine_ &&
-        this.manifest_,
+        this.cmcdManager_ && this.manifest_,
         'Must not be destroyed');
 
     /** @type {shaka.media.StreamingEngine.PlayerInterface} */
     const playerInterface = {
       getPresentationTime: () => this.playhead_.getTime(),
       getBandwidthEstimate: () => this.abrManager_.getBandwidthEstimate(),
+      modifySegmentRequest: (request, segmentInfo) => {
+        this.cmcdManager_.applySegmentData(request, segmentInfo);
+      },
       mediaSourceEngine: this.mediaSourceEngine_,
       netEngine: this.networkingEngine_,
       onError: (error) => this.onError_(error),
       onEvent: (event) => this.dispatchEvent(event),
       onManifestUpdate: () => this.onManifestUpdate_(),
       onSegmentAppended: () => this.onSegmentAppended_(),
+      onInitSegmentAppended: (position, initSegment) => {
+        const mediaQuality = initSegment.getMediaQuality();
+        if (mediaQuality && this.qualityObserver_) {
+          this.qualityObserver_.addMediaQualityChange(mediaQuality, position);
+        }
+      },
     };
 
     return new shaka.media.StreamingEngine(this.manifest_, playerInterface);
@@ -3455,7 +3612,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       const height = fullImageHeight / rows;
       const totalImages = columns * rows;
       const segmentDuration = reference.trueEndTime - reference.startTime;
-      const thumbnailDuration = segmentDuration / totalImages;
+      const thumbnailDuration =
+          reference.getTileDuration() || (segmentDuration / totalImages);
       let thumbnailTime = reference.startTime;
       let positionX = 0;
       let positionY = 0;
@@ -3478,6 +3636,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         positionY = Math.floor(thumbnailPosition / columns) * height;
       }
       return {
+        imageHeight: fullImageHeight,
+        imageWidth: fullImageWidth,
         height: height,
         positionX: positionX,
         positionY: positionY,
@@ -3879,20 +4039,24 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const LanguageUtils = shaka.util.LanguageUtils;
     const inputlanguage = LanguageUtils.normalize(language);
     const chaptersTracks = this.getChaptersTracks_();
-    const chaptersTrack = chaptersTracks
-        .find((t) => LanguageUtils.normalize(t.language) == inputlanguage);
-    if (!chaptersTrack || !chaptersTrack.cues) {
+    const chaptersTracksWithLanguage = chaptersTracks
+        .filter((t) => LanguageUtils.normalize(t.language) == inputlanguage);
+    if (!chaptersTracksWithLanguage || !chaptersTracksWithLanguage.length) {
       return [];
     }
     const chapters = [];
-    for (const cue of chaptersTrack.cues) {
-      /** @type {shaka.extern.Chapter} */
-      const chapter = {
-        title: cue.text,
-        startTime: cue.startTime,
-        endTime: cue.endTime,
-      };
-      chapters.push(chapter);
+    for (const chaptersTrack of chaptersTracksWithLanguage) {
+      if (chaptersTrack && chaptersTrack.cues) {
+        for (const cue of chaptersTrack.cues) {
+          /** @type {shaka.extern.Chapter} */
+          const chapter = {
+            title: cue.text,
+            startTime: cue.startTime,
+            endTime: cue.endTime,
+          };
+          chapters.push(chapter);
+        }
+      }
     }
     return chapters;
   }
@@ -4268,7 +4432,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
       const trackElement =
         /** @type {!HTMLTrackElement} */(document.createElement('track'));
-      trackElement.src = uri;
+      trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
       trackElement.label = label || '';
       trackElement.kind = kind;
       trackElement.srclang = language;
@@ -4606,7 +4770,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
     const trackElement =
       /** @type {!HTMLTrackElement} */(document.createElement('track'));
-    trackElement.src = uri;
+    trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
     trackElement.label = label;
     trackElement.kind = kind;
     trackElement.srclang = language;
@@ -4635,6 +4799,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
     request.method = 'GET';
 
+    this.cmcdManager_.applyTextData(request);
+
     const response = await netEngine.request(type, request).promise;
 
     return response.data;
@@ -5032,13 +5198,17 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     if (loaded) {
       this.playRateController_.setBuffering(isBuffering);
+      if (this.cmcdManager_) {
+        this.cmcdManager_.setBuffering(isBuffering);
+      }
       this.updateStateHistory_();
     }
 
     // Surface the buffering event so that the app knows if/when we are
     // buffering.
     const eventName = shaka.Player.EventName.Buffering;
-    this.dispatchEvent(this.makeEvent_(eventName, {'buffering': isBuffering}));
+    const data = (new Map()).set('buffering', isBuffering);
+    this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
   /**
@@ -5400,10 +5570,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   onAdaptation_(from, to) {
     // Delay the 'adaptation' event so that StreamingEngine has time to absorb
     // the changes before the user tries to query it.
-    const event = this.makeEvent_(shaka.Player.EventName.Adaptation, {
-      oldTrack: from,
-      newTrack: to,
-    });
+    const data = new Map()
+        .set('oldTrack', from)
+        .set('newTrack', to);
+    const event = this.makeEvent_(shaka.Player.EventName.Adaptation, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -5427,10 +5597,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   onVariantChanged_(from, to) {
     // Delay the 'variantchanged' event so StreamingEngine has time to absorb
     // the changes before the user tries to query it.
-    const event = this.makeEvent_(shaka.Player.EventName.VariantChanged, {
-      oldTrack: from,
-      newTrack: to,
-    });
+    const data = new Map()
+        .set('oldTrack', from)
+        .set('newTrack', to);
+    const event = this.makeEvent_(shaka.Player.EventName.VariantChanged, data);
     this.delayDispatchEvent_(event);
   }
 
@@ -5453,10 +5623,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
   /** @private */
   onAbrStatusChanged_() {
-    const event = this.makeEvent_(shaka.Player.EventName.AbrStatusChanged, {
-      newStatus: this.config_.abr.enabled,
-    });
-    this.delayDispatchEvent_(event);
+    const data = (new Map()).set('newStatus', this.config_.abr.enabled);
+    this.delayDispatchEvent_(this.makeEvent_(
+        shaka.Player.EventName.AbrStatusChanged, data));
   }
 
   /**
@@ -5473,7 +5642,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     const eventName = shaka.Player.EventName.Error;
-    const event = this.makeEvent_(eventName, {'detail': error});
+    const event = this.makeEvent_(eventName, (new Map()).set('detail', error));
     this.dispatchEvent(event);
     if (event.defaultPrevented) {
       error.handled = true;
@@ -5502,7 +5671,40 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       eventElement: region.eventElement,
     };
 
-    this.dispatchEvent(this.makeEvent_(eventName, {detail: clone}));
+    const data = (new Map()).set('detail', clone);
+    this.dispatchEvent(this.makeEvent_(eventName, data));
+  }
+
+  /**
+   * When notified of a media quality change we need to emit a
+   * MediaQualityChange event to the app.
+   *
+   * @param {shaka.extern.MediaQualityInfo} mediaQuality
+   * @param {number} position
+   *
+   * @private
+   */
+  onMediaQualityChange_(mediaQuality, position) {
+    // Always make a copy to avoid exposing our internal data to the app.
+    const clone = {
+      bandwidth: mediaQuality.bandwidth,
+      audioSamplingRate: mediaQuality.audioSamplingRate,
+      codecs: mediaQuality.codecs,
+      contentType: mediaQuality.contentType,
+      frameRate: mediaQuality.frameRate,
+      height: mediaQuality.height,
+      mimeType: mediaQuality.mimeType,
+      channelsCount: mediaQuality.channelsCount,
+      pixelAspectRatio: mediaQuality.pixelAspectRatio,
+      width: mediaQuality.width,
+    };
+
+    const data = new Map()
+        .set('mediaQuality', clone)
+        .set('position', position);
+
+    this.dispatchEvent(this.makeEvent_(
+        shaka.Player.EventName.MediaQualityChanged, data));
   }
 
   /**
@@ -6268,6 +6470,8 @@ shaka.Player.EventName = {
   AbrStatusChanged: 'abrstatuschanged',
   Adaptation: 'adaptation',
   Buffering: 'buffering',
+  DownloadFailed: 'downloadfailed',
+  DownloadHeadersReceived: 'downloadheadersreceived',
   DrmSessionUpdate: 'drmsessionupdate',
   Emsg: 'emsg',
   Error: 'error',
@@ -6276,6 +6480,7 @@ shaka.Player.EventName = {
   Loaded: 'loaded',
   Loading: 'loading',
   ManifestParsed: 'manifestparsed',
+  MediaQualityChanged: 'mediaqualitychanged',
   Metadata: 'metadata',
   OnStateChange: 'onstatechange',
   OnStateIdle: 'onstateidle',
@@ -6331,7 +6536,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v3.2.1-uncompiled';
+shaka.Player.version = 'v3.3.1-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.
@@ -6375,6 +6580,7 @@ shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_ = {
   'mpg': 'video/mpeg',
   'mpeg': 'video/mpeg',
   'm3u8': 'application/x-mpegurl',
+  'mpd': 'application/dash+xml',
   'mp3': 'audio/mpeg',
   'aac': 'audio/aac',
   'flac': 'audio/flac',

package/lib/polyfill/media_capabilities.js

@@ -24,8 +24,6 @@ shaka.polyfill.MediaCapabilities = class {
    * @export
    */
   static install() {
-    shaka.log.debug('MediaCapabilities: install');
-
     // Since MediaCapabilities is not fully supported on Chromecast yet, we
     // should always install polyfill for Chromecast.
     // TODO: re-evaluate MediaCapabilities in the future versions of Chromecast.
@@ -34,21 +32,34 @@ shaka.polyfill.MediaCapabilities = class {
     // See: https://github.com/google/shaka-player/issues/3530
     // TODO: re-evaluate MediaCapabilities in the future versions of Apple
     // Browsers.
+    // Since MediaCapabilities implementation is buggy in PS5 browsers, we
+    // should always install polyfill for PS5 browsers.
+    // See: https://github.com/google/shaka-player/issues/3582
+    // TODO: re-evaluate MediaCapabilities in the future versions of PS5
+    // Browsers.
     if (!shaka.util.Platform.isChromecast() &&
-      !shaka.util.Platform.isApple() &&
-      navigator.mediaCapabilities) {
-      shaka.log.debug(
+        !shaka.util.Platform.isApple() &&
+        !shaka.util.Platform.isPS5() &&
+        navigator.mediaCapabilities) {
+      shaka.log.info(
           'MediaCapabilities: Native mediaCapabilities support found.');
-    } else {
-      if (!navigator.mediaCapabilities) {
-        navigator.mediaCapabilities = /** @type {!MediaCapabilities} */ ({});
-      }
-      navigator.mediaCapabilities.decodingInfo =
-          shaka.polyfill.MediaCapabilities.decodingInfo_;
+      return;
+    }
+
+    shaka.log.info('MediaCapabilities: install');
+
+    if (!navigator.mediaCapabilities) {
+      navigator.mediaCapabilities = /** @type {!MediaCapabilities} */ ({});
     }
-    // Workaround because in Apple browsers there is no way to overwrite
-    // MediaCapabilities.
-    window.shakaMediaCapabilities = navigator.mediaCapabilities;
+
+    // Keep the patched MediaCapabilities object from being garbage-collected in
+    // Safari.
+    // See https://github.com/google/shaka-player/issues/3696#issuecomment-1009472718
+    shaka.polyfill.MediaCapabilities.originalMcap =
+        navigator.mediaCapabilities;
+
+    navigator.mediaCapabilities.decodingInfo =
+        shaka.polyfill.MediaCapabilities.decodingInfo_;
   }
 
   /**
@@ -149,7 +160,7 @@ shaka.polyfill.MediaCapabilities = class {
         sessionTypes: mediaCapkeySystemConfig.sessionTypes,
       };
 
-      // Only add the audio video capablities if they have valid data.
+      // Only add the audio video capabilities if they have valid data.
       // Otherwise the query will fail.
       if (audioCapabilities.length) {
         mediaKeySystemConfig.audioCapabilities = audioCapabilities;
@@ -176,6 +187,16 @@ shaka.polyfill.MediaCapabilities = class {
   }
 };
 
+/**
+ * A copy of the MediaCapabilities instance, to prevent Safari from
+ * garbage-collecting the polyfilled method on it.  We make it public and export
+ * it to ensure that it is not stripped out by the compiler.
+ *
+ * @type {MediaCapabilities}
+ * @export
+ */
+shaka.polyfill.MediaCapabilities.originalMcap = null;
+
 // Install at a lower priority than MediaSource polyfill, so that we have
 // MediaSource available first.
 shaka.polyfill.register(shaka.polyfill.MediaCapabilities.install, -1);

package/lib/polyfill/mediasource.js

@@ -208,6 +208,12 @@ shaka.polyfill.MediaSource = class {
   static patchVp09_() {
     const originalIsTypeSupported = MediaSource.isTypeSupported;
 
+    if (shaka.util.Platform.isWebOS()) {
+      // Don't do this on LG webOS as otherwise it is unable
+      // to play vp09 at all.
+      return;
+    }
+
     MediaSource.isTypeSupported = (mimeType) => {
       // Split the MIME type into its various parameters.
       const pieces = mimeType.split(/ *; */);