shaka-player 4.12.4 → 4.12.5

package/lib/dash/dash_parser.js

@@ -1505,6 +1505,9 @@ shaka.dash.DashParser = class {
       let shouldDeleteIndex = true;
       for (const contextId of this.indexStreamMap_[pId]) {
         const stream = this.streamMap_[contextId];
+        if (!stream) {
+          continue;
+        }
         if (stream.segmentIndex && !stream.segmentIndex.isEmpty()) {
           shouldDeleteIndex = false;
           continue;

package/lib/media/drm_engine.js

@@ -928,14 +928,16 @@ shaka.media.DrmEngine = class {
           'Got MediaKeySystemAccess with configuration',
           realConfig);
 
+      const keySystem =
+          this.config_.keySystemsMapping[mediaKeySystemAccess.keySystem] ||
+          mediaKeySystemAccess.keySystem;
+
       if (variants.length) {
         this.currentDrmInfo_ = this.createDrmInfoByInfos_(
-            mediaKeySystemAccess.keySystem,
-            drmInfosByKeySystem.get(mediaKeySystemAccess.keySystem));
+            keySystem, drmInfosByKeySystem.get(keySystem));
       } else {
         this.currentDrmInfo_ = shaka.media.DrmEngine.createDrmInfoByConfigs_(
-            mediaKeySystemAccess.keySystem,
-            configsByKeySystem.get(mediaKeySystemAccess.keySystem));
+            keySystem, configsByKeySystem.get(keySystem));
       }
       if (!this.currentDrmInfo_.licenseServerUri) {
         throw new shaka.util.Error(
@@ -1050,8 +1052,12 @@ shaka.media.DrmEngine = class {
           if (!decodingInfo.supported || !decodingInfo.keySystemAccess) {
             continue;
           }
-          const drmInfos =
-              drmInfosByKeySystem.get(decodingInfo.keySystemAccess.keySystem);
+          const originalKeySystem = decodingInfo.keySystemAccess.keySystem;
+          let drmInfos = drmInfosByKeySystem.get(originalKeySystem);
+          if (!drmInfos && this.config_.keySystemsMapping[originalKeySystem]) {
+            drmInfos = drmInfosByKeySystem.get(
+                this.config_.keySystemsMapping[originalKeySystem]);
+          }
           for (const info of drmInfos) {
             if (!!info.licenseServerUri == shouldHaveLicenseServer) {
               return decodingInfo.keySystemAccess;
@@ -2001,18 +2007,10 @@ shaka.media.DrmEngine = class {
    * @private
    */
   async closeSession_(session) {
-    const DrmEngine = shaka.media.DrmEngine;
-
-    const timeout = new Promise((resolve, reject) => {
-      const timer = new shaka.util.Timer(reject);
-      timer.tickAfter(DrmEngine.CLOSE_TIMEOUT_);
-    });
-
     try {
-      await Promise.race([
-        Promise.all([session.close(), session.closed]),
-        timeout,
-      ]);
+      await shaka.util.Functional.promiseWithTimeout(
+          shaka.media.DrmEngine.CLOSE_TIMEOUT_,
+          Promise.all([session.close(), session.closed]));
     } catch (e) {
       shaka.log.warning('Timeout waiting for session close');
     }

package/lib/media/manifest_filterer.js

@@ -50,7 +50,8 @@ shaka.media.ManifestFilterer = class {
   async filterManifest(manifest) {
     goog.asserts.assert(manifest, 'Manifest should exist!');
     await shaka.util.StreamUtils.filterManifest(this.drmEngine_, manifest,
-        this.config_.drm.preferredKeySystems);
+        this.config_.drm.preferredKeySystems,
+        this.config_.drm.keySystemsMapping);
     if (!this.config_.streaming.dontChooseCodecs) {
       shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
           manifest,

package/lib/media/media_source_engine.js

@@ -466,12 +466,12 @@ shaka.media.MediaSourceEngine = class {
       cleanup.push(this.textEngine_.destroy());
     }
 
+    await Promise.all(cleanup);
+
     for (const contentType in this.transmuxers_) {
-      cleanup.push(this.transmuxers_[contentType].destroy());
+      this.transmuxers_[contentType].destroy();
     }
 
-
-    await Promise.all(cleanup);
     if (this.eventManager_) {
       this.eventManager_.release();
       this.eventManager_ = null;
@@ -692,7 +692,8 @@ shaka.media.MediaSourceEngine = class {
    * @return {boolean}
    */
   isStreamingAllowed() {
-    return this.streamingAllowed_ && !this.usingRemotePlayback_;
+    return this.streamingAllowed_ && !this.usingRemotePlayback_ &&
+        !this.reloadingMediaSource_;
   }
 
   /**
@@ -1859,11 +1860,13 @@ shaka.media.MediaSourceEngine = class {
 
     /** @type {!Array.<!shaka.util.PublicPromise>} */
     const allWaiters = [];
+    /** @type {!Array.<!shaka.util.ManifestParserUtils.ContentType>} */
+    const contentTypes = Object.keys(this.sourceBuffers_);
 
     // Enqueue a 'wait' operation onto each queue.
     // This operation signals its readiness when it starts.
     // When all wait operations are ready, the real operation takes place.
-    for (const contentType in this.sourceBuffers_) {
+    for (const contentType of contentTypes) {
       const ready = new shaka.util.PublicPromise();
       const operation = {
         start: () => ready.resolve(),
@@ -1893,7 +1896,7 @@ shaka.media.MediaSourceEngine = class {
       // assert at the end of destroy passes.  In compiled mode, the queues
       // are wiped in destroy.
       if (goog.DEBUG) {
-        for (const contentType in this.sourceBuffers_) {
+        for (const contentType of contentTypes) {
           if (this.queues_[contentType].length) {
             goog.asserts.assert(
                 this.queues_[contentType].length == 1,
@@ -1910,7 +1913,7 @@ shaka.media.MediaSourceEngine = class {
 
     if (goog.DEBUG) {
       // If we did it correctly, nothing is updating.
-      for (const contentType in this.sourceBuffers_) {
+      for (const contentType of contentTypes) {
         goog.asserts.assert(
             this.sourceBuffers_[contentType].updating == false,
             'SourceBuffers should not be updating after a blocking op!');
@@ -1930,7 +1933,7 @@ shaka.media.MediaSourceEngine = class {
           null);
     } finally {
       // Unblock the queues.
-      for (const contentType in this.sourceBuffers_) {
+      for (const contentType of contentTypes) {
         this.popFromQueue_(contentType);
       }
     }
@@ -1942,6 +1945,7 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   popFromQueue_(contentType) {
+    goog.asserts.assert(this.queues_[contentType], 'Queue should exist');
     // Remove the in-progress operation, which is now complete.
     this.queues_[contentType].shift();
     this.startOperation_(contentType);
@@ -2099,48 +2103,6 @@ shaka.media.MediaSourceEngine = class {
         null);
   }
 
-  /**
-   * Returns the source buffer parameters
-   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @return {?shaka.media.MediaSourceEngine.SourceBufferParams}
-   * @private
-   */
-  getSourceBufferParams_(contentType) {
-    if (!this.sourceBuffers_[contentType]) {
-      return null;
-    }
-    return {
-      timestampOffset: this.sourceBuffers_[contentType].timestampOffset,
-      appendWindowStart: this.sourceBuffers_[contentType].appendWindowStart,
-      appendWindowEnd: this.sourceBuffers_[contentType].appendWindowEnd,
-    };
-  }
-
-  /**
-   * Restore source buffer parameters
-   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {?shaka.media.MediaSourceEngine.SourceBufferParams} params
-   * @private
-   */
-  restoreSourceBufferParams_(contentType, params) {
-    if (!params) {
-      return;
-    }
-
-    if (!this.sourceBuffers_[contentType]) {
-      shaka.log.warning('Attempted to restore a non-existent source buffer');
-      return;
-    }
-
-    this.sourceBuffers_[contentType].timestampOffset =
-      params.timestampOffset;
-    // `end` needs to be set before `start`
-    this.sourceBuffers_[contentType].appendWindowEnd =
-      params.appendWindowEnd;
-    this.sourceBuffers_[contentType].appendWindowStart =
-      params.appendWindowStart;
-  }
-
   /**
    * Resets the MediaSource and re-adds source buffers due to codec mismatch
    *
@@ -2149,7 +2111,6 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   async reset_(streamsByType) {
-    const Functional = shaka.util.Functional;
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     this.reloadingMediaSource_ = true;
     this.needSplitMuxedContent_ = false;
@@ -2171,36 +2132,19 @@ shaka.media.MediaSourceEngine = class {
     try {
       this.eventManager_.removeAll();
 
-      const cleanup = [];
       for (const contentType in this.transmuxers_) {
-        cleanup.push(this.transmuxers_[contentType].destroy());
-      }
-      for (const contentType in this.queues_) {
-        // Make a local copy of the queue and the first item.
-        const q = this.queues_[contentType];
-        const inProgress = q[0];
-
-        // Drop everything else out of the original queue.
-        this.queues_[contentType] = q.slice(0, 1);
-
-        // We will wait for this item to complete/fail.
-        if (inProgress) {
-          cleanup.push(inProgress.p.catch(Functional.noop));
-        }
-
-        // The rest will be rejected silently if possible.
-        for (const item of q.slice(1)) {
-          item.p.reject(shaka.util.Destroyer.destroyedError());
-        }
+        this.transmuxers_[contentType].destroy();
       }
       for (const contentType in this.sourceBuffers_) {
         const sourceBuffer = this.sourceBuffers_[contentType];
         try {
           this.mediaSource_.removeSourceBuffer(sourceBuffer);
-        } catch (e) {}
+        } catch (e) {
+          shaka.log.debug('Exception on removeSourceBuffer', e);
+        }
       }
-      await Promise.all(cleanup);
       this.transmuxers_ = {};
+      this.sourceBuffers_ = {};
 
       const previousDuration = this.mediaSource_.duration;
       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
@@ -2231,23 +2175,17 @@ shaka.media.MediaSourceEngine = class {
           onSourceBufferAdded);
 
       for (const contentType of streamsByType.keys()) {
-        const previousParams = this.getSourceBufferParams_(contentType);
         const stream = streamsByType.get(contentType);
         // eslint-disable-next-line no-await-in-loop
         await this.initSourceBuffer_(contentType, stream, stream.codecs);
-        if (this.needSplitMuxedContent_) {
-          this.queues_[ContentType.AUDIO] = [];
-          this.queues_[ContentType.VIDEO] = [];
-        } else {
-          this.queues_[contentType] = [];
-        }
-
-        this.restoreSourceBufferParams_(contentType, previousParams);
       }
       const audio = streamsByType.get(ContentType.AUDIO);
       if (audio && audio.isAudioMuxedInVideo) {
         this.needSplitMuxedContent_ = true;
       }
+      if (this.needSplitMuxedContent_ && !this.queues_[ContentType.AUDIO]) {
+        this.queues_[ContentType.AUDIO] = [];
+      }
 
       // Fake a seek to catchup the playhead.
       this.video_.currentTime = currentTime;
@@ -2393,13 +2331,12 @@ shaka.media.MediaSourceEngine = class {
    * Returns true if it's necessary codec switch to load the new stream.
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {shaka.extern.Stream} stream
    * @param {string} refMimeType
    * @param {string} refCodecs
    * @return {boolean}
    * @private
    */
-  isCodecSwitchNecessary_(contentType, stream, refMimeType, refCodecs) {
+  isCodecSwitchNecessary_(contentType, refMimeType, refCodecs) {
     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
       return false;
     }
@@ -2443,13 +2380,12 @@ shaka.media.MediaSourceEngine = class {
    * new stream.
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {shaka.extern.Stream} stream
    * @param {string} mimeType
    * @param {string} codecs
    * @return {boolean}
    */
-  isResetMediaSourceNecessary(contentType, stream, mimeType, codecs) {
-    if (!this.isCodecSwitchNecessary_(contentType, stream, mimeType, codecs)) {
+  isResetMediaSourceNecessary(contentType, mimeType, codecs) {
+    if (!this.isCodecSwitchNecessary_(contentType, mimeType, codecs)) {
       return false;
     }
 
@@ -2540,12 +2476,3 @@ shaka.media.MediaSourceEngine.SourceBufferMode_ = {
  *   Called when an embedded 'emsg' box should trigger a manifest update.
  */
 shaka.media.MediaSourceEngine.PlayerInterface;
-
-/**
- * @typedef {{
- *   timestampOffset: number,
- *   appendWindowStart: number,
- *   appendWindowEnd: number
- * }}
- */
-shaka.media.MediaSourceEngine.SourceBufferParams;

package/lib/media/streaming_engine.js

@@ -2011,7 +2011,7 @@ shaka.media.StreamingEngine = class {
       const isResetMediaSourceNecessary =
           mediaState.lastCodecs && mediaState.lastMimeType &&
           this.playerInterface_.mediaSourceEngine.isResetMediaSourceNecessary(
-              mediaState.type, mediaState.stream, mimeType, fullCodecs);
+              mediaState.type, mimeType, fullCodecs);
       if (isResetMediaSourceNecessary) {
         let otherState = null;
         if (mediaState.type === ContentType.VIDEO) {
@@ -2025,6 +2025,10 @@ shaka.media.StreamingEngine = class {
           // 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;
+          // Clear cache of append window start and end, since they will need
+          // to be reapplied post-reload by streaming engine.
+          otherState.lastAppendWindowStart = null;
+          otherState.lastAppendWindowEnd = 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
@@ -2729,6 +2733,8 @@ shaka.media.StreamingEngine = class {
     const audioMediaState = this.mediaStates_.get(ContentType.AUDIO);
     if (audioMediaState) {
       audioMediaState.lastInitSegmentReference = null;
+      audioMediaState.lastAppendWindowStart = null;
+      audioMediaState.lastAppendWindowEnd = null;
       if (clearBuffer) {
         this.forceClearBuffer_(audioMediaState);
       }
@@ -2740,6 +2746,8 @@ shaka.media.StreamingEngine = class {
     const videoMediaState = this.mediaStates_.get(ContentType.VIDEO);
     if (videoMediaState) {
       videoMediaState.lastInitSegmentReference = null;
+      videoMediaState.lastAppendWindowStart = null;
+      videoMediaState.lastAppendWindowEnd = null;
       if (clearBuffer) {
         this.forceClearBuffer_(videoMediaState);
       }

package/lib/offline/storage.js

@@ -702,7 +702,7 @@ shaka.offline.Storage = class {
     // to play later (no point storing something we can't play).
     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
         drmEngine, manifest, config.offline.usePersistentLicense,
-        config.drm.preferredKeySystems);
+        config.drm.preferredKeySystems, config.drm.keySystemsMapping);
 
     // Gather all tracks.
     const allTracks = [];

package/lib/player.js

@@ -3136,15 +3136,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       fullyLoaded.reject(this.videoErrorToShakaError_());
     });
 
-    const timeout = new Promise((resolve, reject) => {
-      const timer = new shaka.util.Timer(reject);
-      timer.tickAfter(this.config_.streaming.loadTimeout);
-    });
-
-    await Promise.race([
-      fullyLoaded,
-      timeout,
-    ]);
+    await shaka.util.Functional.promiseWithTimeout(
+        this.config_.streaming.loadTimeout, fullyLoaded);
 
     const isLive = this.isLive();
 
@@ -8275,7 +8268,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat, max-len
-shaka.Player.version = 'v4.12.4' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.12.5' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/util/mime_utils.js

@@ -179,6 +179,9 @@ shaka.util.MimeUtils = class {
         return 'vvc'; // H266
       case base === 'dvh1':
       case base === 'dvhe':
+        if (profile && profile.startsWith('05')) {
+          return 'dovi-p5'; // Dolby Vision profile 5
+        }
         return 'dovi-hevc'; // Dolby Vision based in HEVC
       case base === 'dvav':
       case base === 'dva1':

package/lib/util/object_utils.js

@@ -89,4 +89,87 @@ shaka.util.ObjectUtils = class {
     }
     return clone;
   }
+
+
+  /**
+   * Constructs a string out of a value, similar to the JSON.stringify method.
+   * Unlike that method, this guarantees that the order of the keys in an
+   * object is alphabetical, so it can be used as a way to reliably compare two
+   * objects.
+   *
+   * @param {?} value
+   * @return {string}
+   */
+  static alphabeticalKeyOrderStringify(value) {
+    if (Array.isArray(value)) {
+      return shaka.util.ObjectUtils.arrayStringify_(value);
+    } else if (typeof value == 'function') {
+      // For safety, skip functions.  For function x,
+      // x.prototype.constructor.prototype === x.prototype, so all functions
+      // contain circular references if treated like Objects.
+      return '';
+    } else if (value instanceof Object) {
+      return shaka.util.ObjectUtils.objectStringify_(value);
+    } else {
+      return JSON.stringify(value);
+    }
+  }
+
+
+  /**
+   * Helper for alphabeticalKeyOrderStringify for objects.
+   *
+   * @param {!Object} obj
+   * @return {string}
+   * @private
+   */
+  static objectStringify_(obj) {
+    // NOTE: This excludes prototype chain keys.  For now, this is intended for
+    // anonymous objects only, so we don't care.  If that changes, go back to a
+    // for-in loop.
+    const keys = Object.keys(obj);
+    // Alphabetically sort the keys, so they will be in a reliable order.
+    keys.sort();
+
+    const terms = [];
+    for (const key of keys) {
+      const escapedKey = JSON.stringify(key);
+      const value = obj[key];
+      if (value !== undefined) {
+        const escapedValue =
+            shaka.util.ObjectUtils.alphabeticalKeyOrderStringify(value);
+        if (escapedValue) {
+          terms.push(escapedKey + ':' + escapedValue);
+        }
+      }
+    }
+    return '{' + terms.join(',') + '}';
+  }
+
+
+  /**
+   * Helper for alphabeticalKeyOrderStringify for arrays.
+   *
+   * This could itself be JSON.stringify, except we want objects within the
+   * array to go through our own stringifiers.
+   *
+   * @param {!Array} arr
+   * @return {string}
+   * @private
+   */
+  static arrayStringify_(arr) {
+    const terms = [];
+    for (let index = 0; index < arr.length; index++) {
+      const escapedKey = index.toString();
+      const value = arr[index];
+      if (value !== undefined) {
+        const escapedValue =
+            shaka.util.ObjectUtils.alphabeticalKeyOrderStringify(value);
+        if (escapedValue) {
+          terms.push(escapedKey + ':' + escapedValue);
+        }
+      }
+    }
+    return '[' + terms.join(',') + ']';
+  }
 };

package/lib/util/platform.js

@@ -780,46 +780,6 @@ shaka.util.Platform = class {
         shaka.log.alwaysWarn('Tizen: Error detecting screen size, default ' +
             'screen size 1920x1080.');
       }
-    } else if (Platform.isXboxOne()) {
-      maxResolution.width = 1920;
-      maxResolution.height = 1080;
-      try {
-        let winRT = undefined;
-
-        // Try to access to WinRT for WebView, if it's not defined,
-        // try to access to WinRT for WebView2, if it's not defined either,
-        // let it throw.
-        if (typeof Windows !== 'undefined') {
-          winRT = Windows;
-        } else {
-          winRT = chrome.webview.hostObjects.sync.Windows;
-        }
-
-        const protectionCapabilities =
-            new winRT.Media.Protection.ProtectionCapabilities();
-        const protectionResult =
-            winRT.Media.Protection.ProtectionCapabilityResult;
-        // isTypeSupported may return "maybe", which means the operation is not
-        // completed. This means we need to retry
-        // https://learn.microsoft.com/en-us/uwp/api/windows.media.protection.protectioncapabilityresult?view=winrt-22621
-        let result = null;
-        const type =
-            'video/mp4;codecs="hvc1,mp4a";features="decode-res-x=3840,' +
-            'decode-res-y=2160,decode-bitrate=20000,decode-fps=30,' +
-            'decode-bpc=10,display-res-x=3840,display-res-y=2160,' +
-            'display-bpc=8"';
-        const keySystem = 'com.microsoft.playready.recommendation';
-        do {
-          result = protectionCapabilities.isTypeSupported(type, keySystem);
-        } while (result === protectionResult.maybe);
-        if (result === protectionResult.probably) {
-          maxResolution.width = 3840;
-          maxResolution.height = 2160;
-        }
-      } catch (e) {
-        shaka.log.alwaysWarn('Xbox: Error detecting screen size, default ' +
-            'screen size 1920x1080.');
-      }
     } else if (Platform.isWebOS()) {
       try {
         const deviceInfo =
@@ -866,6 +826,54 @@ shaka.util.Platform = class {
         maxResolution.width = 1920;
         maxResolution.height = 1080;
       }
+    } else {
+      // For Xbox and UWP apps.
+      let winRT = undefined;
+      try {
+        // Try to access to WinRT for WebView, if it's not defined,
+        // try to access to WinRT for WebView2, if it's not defined either,
+        // let it throw.
+        if (typeof Windows !== 'undefined') {
+          winRT = Windows;
+        } else {
+          winRT = chrome.webview.hostObjects.sync.Windows;
+        }
+      } catch (e) {}
+      if (winRT) {
+        maxResolution.width = 1920;
+        maxResolution.height = 1080;
+        try {
+          const protectionCapabilities =
+              new winRT.Media.Protection.ProtectionCapabilities();
+          const protectionResult =
+              winRT.Media.Protection.ProtectionCapabilityResult;
+          // isTypeSupported may return "maybe", which means the operation
+          // is not completed. This means we need to retry
+          // https://learn.microsoft.com/en-us/uwp/api/windows.media.protection.protectioncapabilityresult?view=winrt-22621
+          let result = null;
+          const type =
+              'video/mp4;codecs="hvc1,mp4a";features="decode-res-x=3840,' +
+              'decode-res-y=2160,decode-bitrate=20000,decode-fps=30,' +
+              'decode-bpc=10,display-res-x=3840,display-res-y=2160,' +
+              'display-bpc=8"';
+          const keySystem = 'com.microsoft.playready.recommendation';
+          do {
+            result = protectionCapabilities.isTypeSupported(type, keySystem);
+          } while (result === protectionResult.maybe);
+          if (result === protectionResult.probably) {
+            maxResolution.width = 3840;
+            maxResolution.height = 2160;
+          }
+        } catch (e) {
+          shaka.log.alwaysWarn('Xbox: Error detecting screen size, default ' +
+              'screen size 1920x1080.');
+        }
+      } else if (Platform.isXboxOne()) {
+        maxResolution.width = 1920;
+        maxResolution.height = 1080;
+        shaka.log.alwaysWarn('Xbox: Error detecting screen size, default ' +
+            'screen size 1920x1080.');
+      }
     }
     return maxResolution;
   }