shaka-player 4.4.3 → 4.6.0

package/lib/util/mutex.js

@@ -0,0 +1,59 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.util.Mutex');
+
+goog.require('shaka.log');
+
+
+/**
+ * @summary A simple mutex.
+ */
+shaka.util.Mutex = class {
+  /** Constructs the mutex. */
+  constructor() {
+    /** @private {?string} */
+    this.acquiredIdentifier = null;
+
+    /** @private {!Array.<function()>} */
+    this.unlockQueue = [];
+  }
+
+  /**
+   * Acquires the mutex, as soon as possible.
+   * @param {string} identifier
+   * @return {!Promise}
+   */
+  async acquire(identifier) {
+    shaka.log.v2(identifier + ' has requested mutex');
+    if (this.acquiredIdentifier) {
+      await new Promise((resolve) => this.unlockQueue.push(resolve));
+    }
+    this.acquiredIdentifier = identifier;
+    shaka.log.v2(identifier + ' has acquired mutex');
+  }
+
+  /**
+   * Releases your hold on the mutex.
+   */
+  release() {
+    shaka.log.v2(this.acquiredIdentifier + ' has released mutex');
+    if (this.unlockQueue.length > 0) {
+      this.unlockQueue.shift()();
+    } else {
+      this.acquiredIdentifier = null;
+    }
+  }
+
+  /**
+   * Completely releases the mutex. Meant for use by the tests.
+   */
+  releaseAll() {
+    while (this.acquiredIdentifier) {
+      this.release();
+    }
+  }
+};

package/lib/util/object_utils.js

@@ -19,7 +19,7 @@ shaka.util.ObjectUtils = class {
    * @return {T}
    */
   static cloneObject(arg) {
-    const seenObjects = new Set();
+    const seenObjects = new WeakSet();
     // This recursively clones the value |val|, using the captured variable
     // |seenObjects| to track the objects we have already cloned.
     /** @suppress {strictMissingProperties} */

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);
       }
     }
   }
@@ -1495,6 +1468,7 @@ shaka.util.PeriodCombiner = class {
     return {
       id: 0,
       originalId: '',
+      groupId: null,
       primary: false,
       type,
       mimeType: '',
@@ -1515,6 +1489,7 @@ shaka.util.PeriodCombiner = class {
       spatialAudio: false,
       closedCaptions: null,
       external: false,
+      fastSwitching: false,
     };
   }
 
@@ -1532,6 +1507,7 @@ shaka.util.PeriodCombiner = class {
     return {
       id: 0,
       originalId: '',
+      groupId: null,
       createSegmentIndex: () => Promise.resolve(),
       segmentIndex: new shaka.media.SegmentIndex([]),
       mimeType: '',
@@ -1554,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;
     }
 
@@ -154,6 +155,26 @@ shaka.util.Platform = class {
             'Chrome/38.0.2125.122 Safari/537.36');
   }
 
+  /**
+   * Check if the current platform is a WebOS 4.
+   *
+   * @return {boolean}
+   */
+  static isWebOS4() {
+    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
+    return !!navigator.userAgent.match(/webOS\/4/i);
+  }
+
+  /**
+   * Check if the current platform is a WebOS 4.
+   *
+   * @return {boolean}
+   */
+  static isWebOS5() {
+    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
+    return !!navigator.userAgent.match(/webOS\/5/i);
+  }
+
   /**
    * Check if the current platform is a Google Chromecast.
    *
@@ -443,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();
   }
 
   /**
@@ -460,6 +481,26 @@ shaka.util.Platform = class {
     return true;
   }
 
+  /**
+   * Returns if codec switching SMOOTH is known reliable device support.
+   *
+   * Some devices are known not to support `MediaSource.changeType`
+   * well. These devices should use the reload strategy. If a device
+   * reports that it supports `changeType` but support it reliabley
+   * it should be added to this list.
+   *
+   * @return {boolean}
+   */
+  static supportsSmoothCodecSwitching() {
+    const Platform = shaka.util.Platform;
+    if (Platform.isTizen2() || Platform.isTizen3() ||
+        Platform.isTizen4() || Platform.isWebOS3() ||
+        Platform.isWebOS4() || Platform.isWebOS5()) {
+      return false;
+    }
+    return true;
+  }
+
   /**
    * Returns true if MediaKeys is polyfilled
    *