shaka-player 4.5.0 → 4.6.0

package/lib/util/periods.js

@@ -103,6 +103,37 @@ shaka.util.PeriodCombiner = class {
     return this.imageStreams_;
   }
 
+  /**
+    * Returns an object that contains arrays of streams by type
+    * @param {!Array.<shaka.extern.Period>} periods
+    * @return {{
+    *  audioStreamsPerPeriod: !Array.<!Array.<shaka.extern.Stream>>,
+    *  videoStreamsPerPeriod: !Array.<!Array.<shaka.extern.Stream>>,
+    *  textStreamsPerPeriod: !Array.<!Array.<shaka.extern.Stream>>,
+    *  imageStreamsPerPeriod: !Array.<!Array.<shaka.extern.Stream>>
+    * }}
+   * @private
+  */
+  getStreamsPerPeriod_(periods) {
+    const audioStreamsPerPeriod = [];
+    const videoStreamsPerPeriod = [];
+    const textStreamsPerPeriod = [];
+    const imageStreamsPerPeriod = [];
+
+    for (const period of periods) {
+      audioStreamsPerPeriod.push(period.audioStreams);
+      videoStreamsPerPeriod.push(period.videoStreams);
+      textStreamsPerPeriod.push(period.textStreams);
+      imageStreamsPerPeriod.push(period.imageStreams);
+    }
+    return {
+      audioStreamsPerPeriod,
+      videoStreamsPerPeriod,
+      textStreamsPerPeriod,
+      imageStreamsPerPeriod,
+    };
+  }
+
   /**
    * @param {!Array.<shaka.extern.Period>} periods
    * @param {boolean} isDynamic
@@ -113,10 +144,7 @@ shaka.util.PeriodCombiner = class {
   async combinePeriods(periods, isDynamic) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    shaka.util.PeriodCombiner.filterOutAudioStreamDuplicates_(periods);
-    shaka.util.PeriodCombiner.filterOutVideoStreamDuplicates_(periods);
-    shaka.util.PeriodCombiner.filterOutTextStreamDuplicates_(periods);
-    shaka.util.PeriodCombiner.filterOutImageStreamDuplicates_(periods);
+    shaka.util.PeriodCombiner.filterOutDuplicates_(periods);
 
     // Optimization: for single-period VOD, do nothing.  This makes sure
     // single-period DASH content will be 100% accurately represented in the
@@ -151,14 +179,12 @@ shaka.util.PeriodCombiner = class {
         return;
       }
 
-      const audioStreamsPerPeriod = periods.map(
-          (period) => period.audioStreams);
-      const videoStreamsPerPeriod = periods.map(
-          (period) => period.videoStreams);
-      const textStreamsPerPeriod = periods.map(
-          (period) => period.textStreams);
-      const imageStreamsPerPeriod = periods.map(
-          (period) => period.imageStreams);
+      const {
+        audioStreamsPerPeriod,
+        videoStreamsPerPeriod,
+        textStreamsPerPeriod,
+        imageStreamsPerPeriod,
+      } = this.getStreamsPerPeriod_(periods);
 
       // It's okay to have a period with no text or images, but our algorithm
       // fails on any period without matching streams.  So we add dummy streams
@@ -174,33 +200,32 @@ shaka.util.PeriodCombiner = class {
             ContentType.IMAGE));
       }
 
-      await shaka.util.PeriodCombiner.combine_(
-          this.audioStreams_,
-          audioStreamsPerPeriod,
-          firstNewPeriodIndex,
-          shaka.util.PeriodCombiner.cloneStream_,
-          shaka.util.PeriodCombiner.concatenateStreams_);
-
-      await shaka.util.PeriodCombiner.combine_(
-          this.videoStreams_,
-          videoStreamsPerPeriod,
-          firstNewPeriodIndex,
-          shaka.util.PeriodCombiner.cloneStream_,
-          shaka.util.PeriodCombiner.concatenateStreams_);
-
-      await shaka.util.PeriodCombiner.combine_(
-          this.textStreams_,
-          textStreamsPerPeriod,
-          firstNewPeriodIndex,
-          shaka.util.PeriodCombiner.cloneStream_,
-          shaka.util.PeriodCombiner.concatenateStreams_);
-
-      await shaka.util.PeriodCombiner.combine_(
-          this.imageStreams_,
-          imageStreamsPerPeriod,
-          firstNewPeriodIndex,
-          shaka.util.PeriodCombiner.cloneStream_,
-          shaka.util.PeriodCombiner.concatenateStreams_);
+      await Promise.all([
+        shaka.util.PeriodCombiner.combine_(
+            this.audioStreams_,
+            audioStreamsPerPeriod,
+            firstNewPeriodIndex,
+            shaka.util.PeriodCombiner.cloneStream_,
+            shaka.util.PeriodCombiner.concatenateStreams_),
+        shaka.util.PeriodCombiner.combine_(
+            this.videoStreams_,
+            videoStreamsPerPeriod,
+            firstNewPeriodIndex,
+            shaka.util.PeriodCombiner.cloneStream_,
+            shaka.util.PeriodCombiner.concatenateStreams_),
+        shaka.util.PeriodCombiner.combine_(
+            this.textStreams_,
+            textStreamsPerPeriod,
+            firstNewPeriodIndex,
+            shaka.util.PeriodCombiner.cloneStream_,
+            shaka.util.PeriodCombiner.concatenateStreams_),
+        shaka.util.PeriodCombiner.combine_(
+            this.imageStreams_,
+            imageStreamsPerPeriod,
+            firstNewPeriodIndex,
+            shaka.util.PeriodCombiner.cloneStream_,
+            shaka.util.PeriodCombiner.concatenateStreams_),
+      ]);
     }
 
     // Create variants for all audio/video combinations.
@@ -209,7 +234,8 @@ shaka.util.PeriodCombiner = class {
     if (!this.videoStreams_.length || !this.audioStreams_.length) {
       // For audio-only or video-only content, just give each stream its own
       // variant.
-      const streams = this.videoStreams_.concat(this.audioStreams_);
+      const streams = this.videoStreams_.length ? this.videoStreams_ :
+        this.audioStreams_;
       for (const stream of streams) {
         const id = nextVariantId++;
         variants.push({
@@ -262,141 +288,90 @@ shaka.util.PeriodCombiner = class {
   }
 
   /**
-   * @param {!Array.<shaka.extern.Period>} periods
+   * @param {!Array<shaka.extern.Period>} periods
    * @private
    */
-  static filterOutAudioStreamDuplicates_(periods) {
-    const ArrayUtils = shaka.util.ArrayUtils;
-    // Two audio streams are considered to be duplicates of
-    // one another if their ids are different, but all the other
-    // information is the same.
-    for (const period of periods) {
-      const filteredAudios = [];
-      for (const a1 of period.audioStreams) {
-        let duplicate = false;
-        for (const a2 of filteredAudios) {
-          if (a1.id != a2.id &&
-              a1.channelsCount == a2.channelsCount &&
-              a1.language == a2.language &&
-              a1.bandwidth == a2.bandwidth &&
-              a1.label == a2.label &&
-              a1.codecs == a2.codecs &&
-              a1.mimeType == a2.mimeType &&
-              ArrayUtils.hasSameElements(a1.roles, a2.roles) &&
-              a1.audioSamplingRate == a2.audioSamplingRate &&
-              a1.primary == a2.primary) {
-            duplicate = true;
-          }
-        }
-
-        if (!duplicate) {
-          filteredAudios.push(a1);
-        }
-      }
-
-      period.audioStreams = filteredAudios;
-    }
-  }
-
-  /**
-   * @param {!Array.<shaka.extern.Period>} periods
-   * @private
-   */
-  static filterOutTextStreamDuplicates_(periods) {
-    const ArrayUtils = shaka.util.ArrayUtils;
-    // Two text streams are considered to be duplicates of
-    // one another if their ids are different, but all the other
-    // information is the same.
-    for (const period of periods) {
-      const filteredTexts = [];
-      for (const t1 of period.textStreams) {
-        let duplicate = false;
-        for (const t2 of filteredTexts) {
-          if (t1.id != t2.id &&
-            t1.language == t2.language &&
-            t1.label == t2.label &&
-            t1.codecs == t2.codecs &&
-            t1.mimeType == t2.mimeType &&
-            t1.bandwidth == t2.bandwidth &&
-            ArrayUtils.hasSameElements(t1.roles, t2.roles)) {
-            duplicate = true;
-          }
-        }
-
-        if (!duplicate) {
-          filteredTexts.push(t1);
-        }
-      }
-
-      period.textStreams = filteredTexts;
-    }
-  }
-
-  /**
-   * @param {!Array.<shaka.extern.Period>} periods
-   * @private
-   */
-  static filterOutVideoStreamDuplicates_(periods) {
+  static filterOutDuplicates_(periods) {
+    const PeriodCombiner = shaka.util.PeriodCombiner;
     const ArrayUtils = shaka.util.ArrayUtils;
     const MapUtils = shaka.util.MapUtils;
-    // Two video streams are considered to be duplicates of
-    // one another if their ids are different, but all the other
-    // information is the same.
+
     for (const period of periods) {
-      const filteredVideos = [];
-      for (const v1 of period.videoStreams) {
-        let duplicate = false;
-        for (const v2 of filteredVideos) {
-          if (v1.id != v2.id &&
-              v1.width == v2.width &&
-              v1.frameRate == v2.frameRate &&
-              v1.codecs == v2.codecs &&
-              v1.mimeType == v2.mimeType &&
-              v1.label == v2.label &&
+      // Two video streams are considered to be duplicates of
+      // one another if their ids are different, but all the other
+      // information is the same.
+      period.videoStreams = PeriodCombiner.filterOutStreamDuplicates_(
+          period.videoStreams, (v1, v2) => {
+            return v1.id !== v2.id &&
+              v1.fastSwitching == v2.fastSwitching &&
+              v1.width === v2.width &&
+              v1.frameRate === v2.frameRate &&
+              v1.codecs === v2.codecs &&
+              v1.mimeType === v2.mimeType &&
+              v1.label === v2.label &&
               ArrayUtils.hasSameElements(v1.roles, v2.roles) &&
               MapUtils.hasSameElements(v1.closedCaptions, v2.closedCaptions) &&
-              v1.bandwidth == v2.bandwidth) {
-            duplicate = true;
-          }
-        }
-
-        if (!duplicate) {
-          filteredVideos.push(v1);
-        }
-      }
-
-      period.videoStreams = filteredVideos;
+              v1.bandwidth === v2.bandwidth;
+          });
+      // Two audio streams are considered to be duplicates of
+      // one another if their ids are different, but all the other
+      // information is the same.
+      period.audioStreams = PeriodCombiner.filterOutStreamDuplicates_(
+          period.audioStreams, (a1, a2) => {
+            return a1.id !== a2.id &&
+              a1.fastSwitching == a2.fastSwitching &&
+              a1.channelsCount === a2.channelsCount &&
+              a1.language === a2.language &&
+              a1.bandwidth === a2.bandwidth &&
+              a1.label === a2.label &&
+              a1.codecs === a2.codecs &&
+              a1.mimeType === a2.mimeType &&
+              ArrayUtils.hasSameElements(a1.roles, a2.roles) &&
+              a1.audioSamplingRate === a2.audioSamplingRate &&
+              a1.primary === a2.primary;
+          });
+      // Two text streams are considered to be duplicates of
+      // one another if their ids are different, but all the other
+      // information is the same.
+      period.textStreams = PeriodCombiner.filterOutStreamDuplicates_(
+          period.textStreams, (t1, t2) => {
+            return t1.id !== t2.id &&
+              t1.language === t2.language &&
+              t1.label === t2.label &&
+              t1.codecs === t2.codecs &&
+              t1.mimeType === t2.mimeType &&
+              t1.bandwidth === t2.bandwidth &&
+              ArrayUtils.hasSameElements(t1.roles, t2.roles);
+          });
+      // Two image streams are considered to be duplicates of
+      // one another if their ids are different, but all the other
+      // information is the same.
+      period.imageStreams = PeriodCombiner.filterOutStreamDuplicates_(
+          period.imageStreams, (i1, i2) => {
+            return i1.id !== i2.id &&
+              i1.width === i2.width &&
+              i1.codecs === i2.codecs &&
+              i1.mimeType === i2.mimeType;
+          });
     }
   }
 
   /**
-   * @param {!Array.<shaka.extern.Period>} periods
+   * @param {!Array<shaka.extern.Stream>} streams
+   * @param {function(
+   *   shaka.extern.Stream, shaka.extern.Stream): boolean} isDuplicate
+   * @return {!Array<shaka.extern.Stream>}
    * @private
    */
-  static filterOutImageStreamDuplicates_(periods) {
-    // Two image streams are considered to be duplicates of
-    // one another if their ids are different, but all the other
-    // information is the same.
-    for (const period of periods) {
-      const filteredImages = [];
-      for (const i1 of period.imageStreams) {
-        let duplicate = false;
-        for (const i2 of filteredImages) {
-          if (i1.id != i2.id &&
-              i1.width == i2.width &&
-              i1.codecs == i2.codecs &&
-              i1.mimeType == i2.mimeType) {
-            duplicate = true;
-          }
-        }
-
-        if (!duplicate) {
-          filteredImages.push(i1);
-        }
+  static filterOutStreamDuplicates_(streams, isDuplicate) {
+    const filteredStreams = [];
+    for (const s1 of streams) {
+      const duplicate = filteredStreams.some((s2) => isDuplicate(s1, s2));
+      if (!duplicate) {
+        filteredStreams.push(s1);
       }
-
-      period.imageStreams = filteredImages;
     }
+    return filteredStreams;
   }
 
   /**
@@ -784,27 +759,25 @@ shaka.util.PeriodCombiner = class {
 
     // Concatenate the new matches onto the stream, starting at the first new
     // period.
-    for (let i = 0; i < matches.length; i++) {
-      if (i >= firstNewPeriodIndex) {
-        const match = matches[i];
-        concat(outputStream, match);
-
-        // We only consider an audio stream "used" if its language is related to
-        // the output language.  There are scenarios where we want to generate
-        // separate tracks for each language, even when we are forced to connect
-        // unrelated languages across periods.
-        let used = true;
-        if (outputStream.type == ContentType.AUDIO) {
-          const relatedness = LanguageUtils.relatedness(
-              outputStream.language, match.language);
-          if (relatedness == 0) {
-            used = false;
-          }
+    for (let i = firstNewPeriodIndex; i < matches.length; i++) {
+      const match = matches[i];
+      concat(outputStream, match);
+
+      // We only consider an audio stream "used" if its language is related to
+      // the output language.  There are scenarios where we want to generate
+      // separate tracks for each language, even when we are forced to connect
+      // unrelated languages across periods.
+      let used = true;
+      if (outputStream.type == ContentType.AUDIO) {
+        const relatedness = LanguageUtils.relatedness(
+            outputStream.language, match.language);
+        if (relatedness == 0) {
+          used = false;
         }
+      }
 
-        if (used) {
-          unusedStreamsPerPeriod[i].delete(match);
-        }
+      if (used) {
+        unusedStreamsPerPeriod[i].delete(match);
       }
     }
   }
@@ -1516,6 +1489,7 @@ shaka.util.PeriodCombiner = class {
       spatialAudio: false,
       closedCaptions: null,
       external: false,
+      fastSwitching: false,
     };
   }
 
@@ -1556,6 +1530,7 @@ shaka.util.PeriodCombiner = class {
       closedCaptions: null,
       accessibilityPurpose: null,
       external: false,
+      fastSwitching: false,
     };
   }
 

package/lib/util/platform.js

@@ -23,15 +23,16 @@ shaka.util.Platform = class {
    * @return {boolean}
    */
   static supportsMediaSource() {
+    const mediaSource = window.ManagedMediaSource || window.MediaSource;
     // Browsers that lack a media source implementation will have no reference
     // to |window.MediaSource|. Platforms that we see having problematic media
     // source implementations will have this reference removed via a polyfill.
-    if (!window.MediaSource) {
+    if (!mediaSource) {
       return false;
     }
 
     // Some very old MediaSource implementations didn't have isTypeSupported.
-    if (!MediaSource.isTypeSupported) {
+    if (!mediaSource.isTypeSupported) {
       return false;
     }
 
@@ -463,7 +464,7 @@ shaka.util.Platform = class {
    */
   static requiresEncryptionInfoInAllInitSegments() {
     const Platform = shaka.util.Platform;
-    return Platform.isTizen() || Platform.isXboxOne();
+    return Platform.isTizen() || Platform.isXboxOne() || Platform.isOrange();
   }
 
   /**

package/lib/util/player_configuration.js

@@ -91,6 +91,7 @@ shaka.util.PlayerConfiguration = class {
       // segments to detect key changes.
       parseInbandPsshEnabled: shaka.util.Platform.isXboxOne(),
       minHdcpVersion: '',
+      ignoreDuplicateInitData: !shaka.util.Platform.isTizen2(),
     };
 
     const manifest = {
@@ -148,6 +149,8 @@ shaka.util.PlayerConfiguration = class {
         liveSegmentsDelay: 3,
         sequenceMode: shaka.util.Platform.supportsSequenceMode(),
         ignoreManifestTimestampsInSegmentsMode: false,
+        disableCodecGuessing: false,
+        allowLowLatencyByteRangeOptimization: true,
       },
       mss: {
         manifestPreprocessor: (element) => {
@@ -215,15 +218,19 @@ shaka.util.PlayerConfiguration = class {
       liveSync: false,
       liveSyncMaxLatency: 1,
       liveSyncPlaybackRate: 1.1,
+      liveSyncMinLatency: 0,
+      liveSyncMinPlaybackRate: 1,
     };
 
-    // WebOS, Tizen, and Chromecast have long hardware pipelines that respond
-    // slowly to seeking.  Therefore we should not seek when we detect a stall
+    // WebOS, Tizen, Chromecast and Hisense have long hardware pipelines
+    // that respond slowly to seeking.
+    // Therefore we should not seek when we detect a stall
     // on one of these platforms.  Instead, default stallSkip to 0 to force the
     // stall detector to pause and play instead.
     if (shaka.util.Platform.isWebOS() ||
         shaka.util.Platform.isTizen() ||
-        shaka.util.Platform.isChromecast()) {
+        shaka.util.Platform.isChromecast() ||
+        shaka.util.Platform.isHisense()) {
       streaming.stallSkip = 0;
     }
 
@@ -344,6 +351,7 @@ shaka.util.PlayerConfiguration = class {
       preferredTextRole: '',
       preferredAudioChannelCount: 2,
       preferredVideoHdrLevel: 'AUTO',
+      preferredVideoLayout: '',
       preferredVideoCodecs: [],
       preferredAudioCodecs: [],
       preferForcedSubs: false,
@@ -374,7 +382,8 @@ shaka.util.PlayerConfiguration = class {
     // eslint-disable-next-line require-await
     offline.trackSelectionCallback = async (tracks) => {
       return shaka.util.PlayerConfiguration.defaultTrackSelect(
-          tracks, config.preferredAudioLanguage);
+          tracks, config.preferredAudioLanguage,
+          config.preferredVideoHdrLevel);
     };
 
     return config;
@@ -415,14 +424,34 @@ shaka.util.PlayerConfiguration = class {
   /**
    * @param {!Array.<shaka.extern.Track>} tracks
    * @param {string} preferredAudioLanguage
+   * @param {string} preferredVideoHdrLevel
    * @return {!Array.<shaka.extern.Track>}
    */
-  static defaultTrackSelect(tracks, preferredAudioLanguage) {
+  static defaultTrackSelect(
+      tracks, preferredAudioLanguage, preferredVideoHdrLevel) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const LanguageUtils = shaka.util.LanguageUtils;
 
+    let hdrLevel = preferredVideoHdrLevel;
+    if (hdrLevel == 'AUTO') {
+      // Auto detect the ideal HDR level.
+      if (window.matchMedia('(color-gamut: p3)').matches) {
+        hdrLevel = 'PQ';
+      } else {
+        hdrLevel = 'SDR';
+      }
+    }
+
     /** @type {!Array.<shaka.extern.Track>} */
-    const allVariants = tracks.filter((track) => track.type == 'variant');
+    const allVariants = tracks.filter((track) => {
+      if (track.type != 'variant') {
+        return false;
+      }
+      if (track.hdr && track.hdr != hdrLevel) {
+        return false;
+      }
+      return true;
+    });
 
     /** @type {!Array.<shaka.extern.Track>} */
     let selectedVariants = [];