shaka-player 4.12.4 → 4.12.6

package/lib/util/stream_utils.js

@@ -146,9 +146,10 @@ shaka.util.StreamUtils = class {
       'vp09': 0.9,
       'hevc': 0.85,
       'dovi-hevc': 0.8,
-      'av01': 0.75,
-      'dovi-av1': 0.7,
-      'vvc': 0.65,
+      'dovi-p5': 0.75,
+      'av01': 0.7,
+      'dovi-av1': 0.65,
+      'vvc': 0.6,
     };
 
     const videoStreams = Array.from(videoStreamsSet)
@@ -393,11 +394,13 @@ shaka.util.StreamUtils = class {
    * @param {shaka.media.DrmEngine} drmEngine
    * @param {shaka.extern.Manifest} manifest
    * @param {!Array<string>=} preferredKeySystems
+   * @param {!Object.<string, string>=} keySystemsMapping
    */
-  static async filterManifest(drmEngine, manifest, preferredKeySystems = []) {
+  static async filterManifest(drmEngine, manifest, preferredKeySystems = [],
+      keySystemsMapping = {}) {
     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
         drmEngine, manifest, manifest.offlineSessionIds.length > 0,
-        preferredKeySystems);
+        preferredKeySystems, keySystemsMapping);
     shaka.util.StreamUtils.filterTextStreams_(manifest);
     await shaka.util.StreamUtils.filterImageStreams_(manifest);
   }
@@ -411,9 +414,11 @@ shaka.util.StreamUtils = class {
    * @param {shaka.extern.Manifest} manifest
    * @param {boolean} usePersistentLicenses
    * @param {!Array<string>} preferredKeySystems
+   * @param {!Object.<string, string>} keySystemsMapping
    */
   static async filterManifestByMediaCapabilities(
-      drmEngine, manifest, usePersistentLicenses, preferredKeySystems) {
+      drmEngine, manifest, usePersistentLicenses, preferredKeySystems,
+      keySystemsMapping) {
     goog.asserts.assert(navigator.mediaCapabilities,
         'MediaCapabilities should be valid.');
 
@@ -435,7 +440,8 @@ shaka.util.StreamUtils = class {
     const StreamUtils = shaka.util.StreamUtils;
 
     manifest.variants = manifest.variants.filter((variant) => {
-      const supported = StreamUtils.checkVariantSupported_(variant, keySystem);
+      const supported = StreamUtils.checkVariantSupported_(
+          variant, keySystem, keySystemsMapping);
       // Filter out all unsupported variants.
       if (!supported) {
         shaka.log.debug('Dropping variant - not compatible with platform',
@@ -485,15 +491,31 @@ shaka.util.StreamUtils = class {
   /**
    * @param {!shaka.extern.Variant} variant
    * @param {?string} keySystem
+   * @param {!Object.<string, string>} keySystemsMapping
    * @return {boolean}
    * @private
    */
-  static checkVariantSupported_(variant, keySystem) {
-    const ContentType = shaka.util.ManifestParserUtils.ContentType;
-    const Capabilities = shaka.media.Capabilities;
-    const ManifestParserUtils = shaka.util.ManifestParserUtils;
-    const MimeUtils = shaka.util.MimeUtils;
-    const StreamUtils = shaka.util.StreamUtils;
+  static checkVariantSupported_(variant, keySystem, keySystemsMapping) {
+    const variantSupported = variant.decodingInfos.some((decodingInfo) => {
+      if (!decodingInfo.supported) {
+        return false;
+      }
+      if (keySystem) {
+        const keySystemAccess = decodingInfo.keySystemAccess;
+        if (keySystemAccess) {
+          const currentKeySystem =
+              keySystemsMapping[keySystemAccess.keySystem] ||
+              keySystemAccess.keySystem;
+          if (currentKeySystem != keySystem) {
+            return false;
+          }
+        }
+      }
+      return true;
+    });
+    if (!variantSupported) {
+      return false;
+    }
 
     const isXboxOne = shaka.util.Platform.isXboxOne();
     const isFirefoxAndroid = shaka.util.Platform.isFirefox() &&
@@ -511,43 +533,6 @@ shaka.util.StreamUtils = class {
       return false;
     }
 
-    if (video) {
-      let videoCodecs = StreamUtils.getCorrectVideoCodecs(video.codecs);
-      // For multiplexed streams. Here we must check the audio of the
-      // stream to see if it is compatible.
-      if (video.codecs.includes(',')) {
-        const allCodecs = video.codecs.split(',');
-
-        videoCodecs = ManifestParserUtils.guessCodecs(
-            ContentType.VIDEO, allCodecs);
-        videoCodecs = StreamUtils.getCorrectVideoCodecs(videoCodecs);
-        let audioCodecs = ManifestParserUtils.guessCodecs(
-            ContentType.AUDIO, allCodecs);
-        audioCodecs = StreamUtils.getCorrectAudioCodecs(
-            audioCodecs, video.mimeType);
-
-        const audioFullType = MimeUtils.getFullOrConvertedType(
-            video.mimeType, audioCodecs, ContentType.AUDIO);
-
-        if (!Capabilities.isTypeSupported(audioFullType)) {
-          return false;
-        }
-
-        // Update the codec string with the (possibly) converted codecs.
-        videoCodecs = [videoCodecs, audioCodecs].join(',');
-      }
-
-      const fullType = MimeUtils.getFullOrConvertedType(
-          video.mimeType, videoCodecs, ContentType.VIDEO);
-
-      if (!Capabilities.isTypeSupported(fullType)) {
-        return false;
-      }
-
-      // Update the codec string with the (possibly) converted codecs.
-      video.codecs = videoCodecs;
-    }
-
     const audio = variant.audio;
 
     // See: https://github.com/shaka-project/shaka-player/issues/6111
@@ -559,68 +544,7 @@ shaka.util.StreamUtils = class {
       return false;
     }
 
-    if (audio) {
-      const codecs = StreamUtils.getCorrectAudioCodecs(
-          audio.codecs, audio.mimeType);
-      const fullType = MimeUtils.getFullOrConvertedType(
-          audio.mimeType, codecs, ContentType.AUDIO);
-
-      if (!Capabilities.isTypeSupported(fullType)) {
-        return false;
-      }
-
-      // Update the codec string with the (possibly) converted codecs.
-      audio.codecs = codecs;
-    }
-
-    return variant.decodingInfos.some((decodingInfo) => {
-      if (!decodingInfo.supported) {
-        return false;
-      }
-      if (keySystem) {
-        const keySystemAccess = decodingInfo.keySystemAccess;
-        if (keySystemAccess) {
-          if (keySystemAccess.keySystem != keySystem) {
-            return false;
-          }
-        }
-      }
-      return true;
-    });
-  }
-
-
-  /**
-   * Constructs a string out of an object, similar to the JSON.stringify method.
-   * Unlike that method, this guarantees that the order of the keys is
-   * alphabetical, so it can be used as a way to reliably compare two objects.
-   *
-   * @param {!Object} obj
-   * @return {string}
-   * @private
-   */
-  static alphabeticalKeyOrderStringify_(obj) {
-    const keys = [];
-    for (const key in obj) {
-      keys.push(key);
-    }
-    // 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 instanceof Object) {
-        const stringifiedValue =
-            shaka.util.StreamUtils.alphabeticalKeyOrderStringify_(value);
-        terms.push(escapedKey + ':' + stringifiedValue);
-      } else {
-        const escapedValue = JSON.stringify(value);
-        terms.push(escapedKey + ':' + escapedValue);
-      }
-    }
-    return '{' + terms.join(',') + '}';
+    return true;
   }
 
 
@@ -659,7 +583,7 @@ shaka.util.StreamUtils = class {
     const promises = [];
     for (const decodingConfig of decodingConfigs) {
       const cacheKey =
-          StreamUtils.alphabeticalKeyOrderStringify_(decodingConfig);
+          shaka.util.ObjectUtils.alphabeticalKeyOrderStringify(decodingConfig);
 
       const cache = StreamUtils.decodingConfigCache_;
       if (cache[cacheKey]) {

package/lib/util/ts_parser.js

@@ -517,7 +517,11 @@ shaka.util.TsParser = class {
     shaka.Deprecate.deprecateFeature(5,
         'TsParser.parseAvcNalus',
         'Please use parseNalus function instead.');
-    return this.parseNalus(pes);
+    const lastInfo = {
+      nalu: null,
+      state: null,
+    };
+    return this.parseNalus(pes, lastInfo);
   }
 
   /**
@@ -527,12 +531,11 @@ shaka.util.TsParser = class {
    * Credit to https://github.com/video-dev/hls.js/blob/master/src/demux/tsdemuxer.ts
    *
    * @param {shaka.extern.MPEG_PES} pes
-   * @param {?shaka.extern.VideoNalu=} lastNalu
-   * @param {?number=} lastState
+   * @param {{nalu: ?shaka.extern.VideoNalu, state: ?number}} lastInfo
    * @return {!Array.<shaka.extern.VideoNalu>}
    * @export
    */
-  parseNalus(pes, lastNalu, lastState) {
+  parseNalus(pes, lastInfo) {
     const timescale = shaka.util.TsParser.Timescale;
     const time = pes.pts ? pes.pts / timescale : null;
     const data = pes.data;
@@ -548,7 +551,12 @@ shaka.util.TsParser = class {
     // precede each NALU. A start code is 2 or 3 0x00 bytes followed with a
     // 0x01 byte. e.g. 0x000001 or 0x00000001.
     // More info in: https://stackoverflow.com/questions/24884827/possible-locations-for-sequence-picture-parameter-sets-for-h-264-stream/24890903#24890903
-    let numZeros = lastState || 0;
+    let numZeros = lastInfo.state || 0;
+
+    const initialNumZeros = numZeros;
+
+    /** @type {number} */
+    let i = 0;
 
     /** @type {!Array.<shaka.extern.VideoNalu>} */
     const nalus = [];
@@ -559,103 +567,119 @@ shaka.util.TsParser = class {
     // Extracted from the first byte.
     let lastNaluType = 0;
 
-    /** @type {?shaka.extern.VideoNalu} */
-    let infoOfLastNalu;
+    const getNaluType = (offset) => {
+      if (this.videoCodec_ == 'hvc') {
+        return (data[offset] >> 1) & 0x3f;
+      } else {
+        return data[offset] & 0x1f;
+      }
+    };
 
-    for (let i = 0; i < len; ++i) {
-      const value = data[i];
-      if (!value) {
-        numZeros++;
-      } else if (numZeros >= 2 && value == 1) {
-        if (lastNalu && !nalus.length && lastNaluStart == -1) {
-          // If we are scanning the next PES, we need append the data to the
-          // previous Nalu and don't scan for more nalus.
-          const startCodeSize = numZeros > 3 ? 3 : numZeros;
-          const lastByteToKeep = i - startCodeSize;
-          // Optimization
-          if (lastState && lastByteToKeep != 0) {
-            const prevData = data.subarray(0, lastByteToKeep);
-            lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
-                lastNalu.data, prevData);
-            lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
-                lastNalu.fullData, prevData);
-          }
-        }
-        // We just read a start code.  Consume the NALU we passed, if any.
-        if (lastNaluStart >= 0) {
-          // Because the start position includes the header size.
-          const firstByteToKeep = lastNaluStart + naluHeaderSize;
+    const getLastNalu = () => {
+      if (nalus.length) {
+        return nalus[nalus.length - 1];
+      }
+      return lastInfo.nalu;
+    };
 
-          // Compute the last byte to keep.  The start code is at most 3 zeros.
-          // Any earlier zeros are not part of the start code.
-          const startCodeSize = (numZeros > 3 ? 3 : numZeros) + 1;
-          const lastByteToKeep = i - startCodeSize;
+    if (numZeros == -1) {
+      // special use case where we found 3 or 4-byte start codes exactly at the
+      // end of previous PES packet
+      lastNaluStart = 0;
+      // NALu type is value read from offset 0
+      lastNaluType = getNaluType(0);
+      numZeros = 0;
+      i = 1;
+    }
 
+    while (i < len) {
+      const value = data[i++];
+      // Optimization. numZeros 0 and 1 are the predominant case.
+      if (!numZeros) {
+        numZeros = value ? 0 : 1;
+        continue;
+      }
+      if (numZeros === 1) {
+        numZeros = value ? 0 : 2;
+        continue;
+      }
+      if (!value) {
+        numZeros = 3;
+      } else if (value == 1) {
+        const overflow = i - numZeros - 1;
+        if (lastNaluStart >= 0) {
           /** @type {shaka.extern.VideoNalu} */
           const nalu = {
-            // subarray's end position is exclusive, so add one.
-            data: data.subarray(firstByteToKeep, lastByteToKeep + 1),
-            fullData: data.subarray(lastNaluStart, lastByteToKeep + 1),
+            data: data.subarray(lastNaluStart + naluHeaderSize, overflow),
+            fullData: data.subarray(lastNaluStart, overflow),
             type: lastNaluType,
             time: time,
+            state: null,
           };
           nalus.push(nalu);
-        } else if (lastNalu && !nalus.length) {
-          const overflow = i - numZeros;
-          if (overflow > 0) {
-            const prevData = data.subarray(0, overflow);
-            lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
-                lastNalu.data, prevData);
-            lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
-                lastNalu.fullData, prevData);
+        } else {
+          const lastNalu = getLastNalu();
+          if (lastNalu) {
+            if (initialNumZeros && i <= 4 - initialNumZeros) {
+              // Start delimiter overlapping between PES packets
+              // strip start delimiter bytes from the end of last NAL unit
+              // check if lastNalu had a state different from zero
+              if (lastNalu.state) {
+                // strip last bytes
+                lastNalu.data = lastNalu.data.subarray(
+                    0, lastNalu.data.byteLength - initialNumZeros);
+                lastNalu.fullData = lastNalu.fullData.subarray(
+                    0, lastNalu.fullData.byteLength - initialNumZeros);
+              }
+            }
+            // If NAL units are not starting right at the beginning of the PES
+            // packet, push preceding data into previous NAL unit.
+            if (overflow > 0) {
+              const prevData = data.subarray(0, overflow);
+              lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
+                  lastNalu.data, prevData);
+              lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
+                  lastNalu.fullData, prevData);
+              lastNalu.state = 0;
+            }
           }
         }
 
-        // We just read a start code, so there should be another byte here, at
-        // least, for the NALU type.  Check just in case.
-        if (i >= len - naluHeaderSize) {
-          shaka.log.warning('Malformed TS, incomplete NALU, ignoring.');
-          return nalus;
-        }
-
-        // Advance and read the type of the next NALU.
-        i++;
-        lastNaluStart = i;
-        if (this.videoCodec_ == 'hvc') {
-          lastNaluType = (data[i] >> 1) & 0x3f;
+        // Check if we can read unit type
+        if (i < len) {
+          lastNaluType = getNaluType(i);
+          lastNaluStart = i;
+          numZeros = 0;
         } else {
-          lastNaluType = data[i] & 0x1f;
+          // Not enough byte to read unit type.
+          // Let's read it on next PES parsing.
+          numZeros = -1;
         }
-        numZeros = 0;
       } else {
         numZeros = 0;
       }
-      // If we have gone through all the data from the PES and we have an
-      // unfinished Nalu, we will try to use the next PES to complete the
-      // unfinished Nalu.
-      if (i >= (len - 1) && lastNaluStart >= 0 && numZeros >= 0) {
-        // The rest of the buffer was a NALU.
-        // Because the start position includes the header size.
-        const firstByteToKeep = lastNaluStart + naluHeaderSize;
-        infoOfLastNalu = {
-          data: data.subarray(firstByteToKeep, len),
-          fullData: data.subarray(lastNaluStart, len),
-          type: lastNaluType,
-          time: time,
-        };
-      }
     }
 
-    if (infoOfLastNalu) {
-      nalus.push(infoOfLastNalu);
+    if (lastNaluStart >= 0 && numZeros >= 0) {
+      const nalu = {
+        data: data.subarray(lastNaluStart + naluHeaderSize, len),
+        fullData: data.subarray(lastNaluStart, len),
+        type: lastNaluType,
+        time: time,
+        state: numZeros,
+      };
+      nalus.push(nalu);
     }
-    if (!nalus.length && lastNalu) {
-      lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
-          lastNalu.data, data);
-      lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
-          lastNalu.fullData, data);
+    if (!nalus.length && lastInfo.nalu) {
+      const lastNalu = getLastNalu();
+      if (lastNalu) {
+        lastNalu.data = shaka.util.Uint8ArrayUtils.concat(
+            lastNalu.data, data);
+        lastNalu.fullData = shaka.util.Uint8ArrayUtils.concat(
+            lastNalu.fullData, data);
+      }
     }
-    lastState = Math.min(3, numZeros);
+    lastInfo.state = numZeros;
     return nalus;
   }
 
@@ -759,14 +783,16 @@ shaka.util.TsParser = class {
         }
       }
       if (naluProcessing) {
-        let lastNalu;
-        let lastState;
+        const lastInfo = {
+          nalu: null,
+          state: null,
+        };
         const pesWithLength = [];
         for (const pes of this.videoPes_) {
-          pes.nalus = this.parseNalus(pes, lastNalu, lastState);
+          pes.nalus = this.parseNalus(pes, lastInfo);
           if (pes.nalus.length) {
             pesWithLength.push(pes);
-            lastNalu = pes.nalus[pes.nalus.length - 1];
+            lastInfo.nalu = pes.nalus[pes.nalus.length - 1];
           }
         }
         this.videoPes_ = pesWithLength;

package/package.json

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

package/ui/ad_counter.js

@@ -100,6 +100,11 @@ shaka.ui.AdCounter = class extends shaka.ui.Element {
     goog.asserts.assert(this.ad != null,
         'this.ad should exist at this point');
 
+    if (!this.ad.isLinear()) {
+      // Do not show information for non-linear ads.
+      return;
+    }
+
     const secondsLeft = Math.round(this.ad.getRemainingTime());
     const adDuration = this.ad.getDuration();
     if (secondsLeft == -1 || adDuration == -1) {

package/ui/controls.js

@@ -868,9 +868,11 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
       return;
     }
 
-    this.player_.cancelTrickPlay();
-
     if (this.presentationIsPaused()) {
+      // If we are at the end, go back to the beginning.
+      if (this.player_.isEnded()) {
+        this.video_.currentTime = this.player_.seekRange().start;
+      }
       this.video_.play();
     } else {
       this.video_.pause();

package/ui/fast_forward_button.js

@@ -81,6 +81,13 @@ shaka.ui.FastForwardButton = class extends shaka.ui.Element {
     // selected. If no more rates are available, the first one is set.
     const newRate = (newRateIndex != this.fastForwardRates_.length) ?
         this.fastForwardRates_[newRateIndex] : this.fastForwardRates_[0];
+
+    if (this.video.paused) {
+      // Our fast forward is implemented with playbackRate and needs the video
+      // to be playing (to not be paused) to take immediate effect.
+      // If the video is paused, "unpause" it.
+      this.video.play();
+    }
     this.player.trickPlay(newRate);
 
     this.button_.setAttribute('shaka-status', newRate + 'x');

package/ui/play_button.js

@@ -116,7 +116,7 @@ shaka.ui.PlayButton = class extends shaka.ui.Element {
       return false;
     }
 
-    return this.video.ended;
+    return this.player ? this.player.isEnded() : true;
   }
 
   /**

package/ui/playback_rate_selection.js

@@ -121,7 +121,7 @@ shaka.ui.PlaybackRateSelection = class extends shaka.ui.SettingsMenu {
 
       this.eventManager.listen(button, 'click', () => {
         const rate = this.playbackRates_.get(rateStr);
-        if (rate == 1) {
+        if (rate == this.video.defaultPlaybackRate) {
           this.player.cancelTrickPlay();
         } else {
           this.player.trickPlay(rate, /* useTrickPlayTrack= */ false);

package/ui/rewind_button.js

@@ -82,6 +82,13 @@ shaka.ui.RewindButton = class extends shaka.ui.Element {
     // selected. If no more rates are available, the first one is set.
     const newRate = (newRateIndex != this.rewindRates_.length) ?
         this.rewindRates_[newRateIndex] : this.rewindRates_[0];
+
+    if (this.video.paused) {
+      // Our fast forward is implemented with playbackRate and needs the video
+      // to be playing (to not be paused) to take immediate effect.
+      // If the video is paused, "unpause" it.
+      this.video.play();
+    }
     this.player.trickPlay(newRate);
 
     this.button_.setAttribute('shaka-status', newRate + 'x');