shaka-player 3.2.1 → 3.3.1

package/lib/util/fake_event.js

@@ -6,6 +6,8 @@
 
 goog.provide('shaka.util.FakeEvent');
 
+goog.require('goog.asserts');
+
 
 /**
  * @summary Create an Event work-alike object based on the provided dictionary.
@@ -16,18 +18,62 @@ goog.provide('shaka.util.FakeEvent');
  */
 shaka.util.FakeEvent = class {
   /**
-   * @param {string} type
-   * @param {Object=} dict
+   * @param {!Event} event
+   * @return {!shaka.util.FakeEvent}
    */
-  constructor(type, dict = {}) {
-    // Take properties from dict if present.
-    for (const key in dict) {
-      Object.defineProperty(this, key, {
-        value: dict[key],
+  static fromRealEvent(event) {
+    const fakeEvent = new shaka.util.FakeEvent(event.type);
+    for (const key in event) {
+      Object.defineProperty(fakeEvent, key, {
+        value: event[key],
         writable: true,
         enumerable: true,
       });
     }
+    return fakeEvent;
+  }
+
+  /**
+   * Allows us to tell the compiler that the dictionary "map" is actually a
+   * generic object, for backwards compatibility.
+   * @param {!Map.<string, Object>} dict
+   * @return {!Object}
+   * @suppress {invalidCasts}
+   * @private
+   */
+  static recastDictAsObject_(dict) {
+    goog.asserts.assert(!(dict instanceof Map), 'dict should not be a map');
+    return /** @type {!Object} */ (dict);
+  }
+
+  /**
+   * @param {string} type
+   * @param {Map.<string, Object>=} dict
+   */
+  constructor(type, dict) {
+    if (dict) {
+      if (dict instanceof Map) {
+        // Take properties from dict if present.
+        for (const key of dict.keys()) {
+          Object.defineProperty(this, key, {
+            value: dict.get(key),
+            writable: true,
+            enumerable: true,
+          });
+        }
+      } else {
+        // For backwards compatibility with external apps that may make use of
+        // this public constructor, this should still accept generic objects.
+        const obj = shaka.util.FakeEvent.recastDictAsObject_(dict);
+        for (const key in obj) {
+          Object.defineProperty(this, key, {
+            value: obj[key],
+            writable: true,
+            enumerable: true,
+          });
+        }
+      }
+    }
 
     // The properties below cannot be set by the dict.  They are all provided
     // for compatibility with native events.

package/lib/util/language_utils.js

@@ -13,6 +13,7 @@ goog.require('shaka.util.ManifestParserUtils');
 /**
  * @summary A set of language utility functions.
  * @final
+ * @export
  */
 shaka.util.LanguageUtils = class {
   /**
@@ -32,6 +33,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} locale1
    * @param {string} locale2
    * @return {boolean}
+   * @export
    */
   static areLocaleCompatible(locale1, locale2) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -62,6 +64,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} locale1
    * @param {string} locale2
    * @return {boolean}
+   * @export
    */
   static areLanguageCompatible(locale1, locale2) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -102,6 +105,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} possibleParent
    * @param {string} possibleChild
    * @return {boolean}
+   * @export
    */
   static isParentOf(possibleParent, possibleChild) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -146,6 +150,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} localeA
    * @param {string} localeB
    * @return {boolean}
+   * @export
    */
   static isSiblingOf(localeA, localeB) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -181,6 +186,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {string} locale
    * @return {string}
+   * @export
    */
   static normalize(locale) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -217,6 +223,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} a
    * @param {string} b
    * @return {boolean}
+   * @export
    */
   static areSiblings(a, b) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -235,6 +242,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} target
    * @param {string} candidate
    * @return {number}
+   * @export
    */
   static relatedness(target, candidate) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -271,6 +279,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {string} lang
    * @return {string}
+   * @export
    */
   static getBase(lang) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -300,6 +309,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {shaka.extern.Stream} stream
    * @return {string}
+   * @export
    */
   static getLocaleForText(stream) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -322,6 +332,7 @@ shaka.util.LanguageUtils = class {
    *
    * @param {shaka.extern.Variant} variant
    * @return {string}
+   * @export
    */
   static getLocaleForVariant(variant) {
     const LanguageUtils = shaka.util.LanguageUtils;
@@ -356,6 +367,7 @@ shaka.util.LanguageUtils = class {
    * @param {string} target
    * @param {!Iterable.<string>} searchSpace
    * @return {?string}
+   * @export
    */
   static findClosestLocale(target, searchSpace) {
     const LanguageUtils = shaka.util.LanguageUtils;

package/lib/util/mutex.js

@@ -0,0 +1,52 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.util.Mutex');
+
+
+/**
+ * @summary A simple mutex.
+ */
+shaka.util.Mutex = class {
+  /** Creates the mutex. */
+  constructor() {
+    /** @private {!Array.<function()>} */
+    this.waiting_ = [];
+
+    /** @private {number} */
+    this.nextMutexId_ = 0;
+
+    /** @private {number} */
+    this.acquiredMutexId_ = 0;
+  }
+
+  /** @return {!Promise.<number>} mutexId */
+  async acquire() {
+    const mutexId = ++this.nextMutexId_;
+    if (!this.acquiredMutexId_) {
+      this.acquiredMutexId_ = mutexId;
+    } else {
+      await (new Promise((resolve, reject) => {
+        this.waiting_.push(() => {
+          this.acquiredMutexId_ = mutexId;
+          resolve();
+        });
+      }));
+    }
+    return mutexId;
+  }
+
+  /** @param {number} mutexId */
+  release(mutexId) {
+    if (mutexId == this.acquiredMutexId_) {
+      this.acquiredMutexId_ = 0;
+      if (this.waiting_.length > 0) {
+        const callback = this.waiting_.shift();
+        callback();
+      }
+    }
+  }
+};

package/lib/util/periods.js

@@ -80,7 +80,10 @@ shaka.util.PeriodCombiner = class {
 
   /** @return {!Array.<shaka.extern.Stream>} */
   getTextStreams() {
-    return this.textStreams_;
+    // Return a copy of the array because makeTextStreamsForClosedCaptions
+    // may make changes to the contents of the array. Those changes should not
+    // propagate back to the PeriodCombiner.
+    return this.textStreams_.slice();
   }
 
   /** @return {!Array.<shaka.extern.Stream>} */
@@ -544,8 +547,7 @@ shaka.util.PeriodCombiner = class {
       for (const stream of unusedStreams) {
         // Create a new output stream which includes this input stream.
         const outputStream =
-            // eslint-disable-next-line no-await-in-loop
-            await shaka.util.PeriodCombiner.createNewOutputStream_(
+            shaka.util.PeriodCombiner.createNewOutputStream_(
                 stream, streamsPerPeriod, clone, concat,
                 unusedStreamsPerPeriod);
         if (outputStream) {
@@ -616,52 +618,69 @@ shaka.util.PeriodCombiner = class {
   static async extendExistingOutputStream_(
       outputStream, streamsPerPeriod, firstNewPeriodIndex, concat,
       unusedStreamsPerPeriod) {
-    const matches = shaka.util.PeriodCombiner.findMatchesInAllPeriods_(
-        streamsPerPeriod, outputStream);
-
-    if (!matches) {
-      // We were unable to extend this output stream.
-      shaka.log.error('No matches extending output stream!',
-          outputStream, streamsPerPeriod);
-      return false;
-    }
+    shaka.util.PeriodCombiner.findMatchesInAllPeriods_(streamsPerPeriod,
+        outputStream);
 
     // This only exists where T == Stream, and this should only ever be called
     // on Stream types.  StreamDB should not have pre-existing output streams.
     goog.asserts.assert(outputStream.createSegmentIndex,
         'outputStream should be a Stream type!');
 
+    if (!outputStream.matchedStreams) {
+      // We were unable to extend this output stream.
+      shaka.log.error('No matches extending output stream!',
+          outputStream, streamsPerPeriod);
+      return false;
+    }
     // We need to create all the per-period segment indexes and append them to
     // the output's MetaSegmentIndex.
-    await shaka.util.PeriodCombiner.createSegmentIndexes_(matches);
-
-    // Assure the compiler that matches didn't become null during the async
-    // operation above.
-    goog.asserts.assert(matches, 'Matches should be non-null');
+    if (outputStream.segmentIndex) {
+      await shaka.util.PeriodCombiner.extendOutputSegmentIndex_(outputStream,
+          firstNewPeriodIndex);
+    }
 
-    shaka.util.PeriodCombiner.extendOutputStream_(
-        outputStream, matches, firstNewPeriodIndex, concat,
-        unusedStreamsPerPeriod);
+    shaka.util.PeriodCombiner.extendOutputStream_(outputStream,
+        firstNewPeriodIndex, concat, unusedStreamsPerPeriod);
     return true;
   }
 
   /**
-   * Creates all segment indexes for an array of streams.  Returns once every
-   * segment index is created.
+   * Creates the segment indexes for an array of input streams, and append them
+   * to the output stream's segment index.
    *
-   * @param {!Array.<!shaka.extern.Stream>} streams
-   * @return {!Promise}
+   * @param {shaka.extern.Stream} outputStream
+   * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
+   *   represents the first new period that hasn't been processed yet.
    * @private
    */
-  static createSegmentIndexes_(streams) {
+  static async extendOutputSegmentIndex_(outputStream, firstNewPeriodIndex) {
     const operations = [];
+    const streams = outputStream.matchedStreams;
+    goog.asserts.assert(streams, 'matched streams should be valid');
+
     for (const stream of streams) {
       operations.push(stream.createSegmentIndex());
       if (stream.trickModeVideo && !stream.trickModeVideo.segmentIndex) {
         operations.push(stream.trickModeVideo.createSegmentIndex());
       }
     }
-    return Promise.all(operations);
+    await Promise.all(operations);
+
+    // Concatenate the new matches onto the stream, starting at the first new
+    // period.
+    const Iterables = shaka.util.Iterables;
+    // Satisfy the compiler about the type.
+    // Also checks if the segmentIndex is still valid after the async
+    // operations, to make sure we stop if the active stream has changed.
+    if (outputStream.segmentIndex instanceof shaka.media.MetaSegmentIndex) {
+      for (const {i, item: match} of Iterables.enumerate(streams)) {
+        if (match.segmentIndex && i >= firstNewPeriodIndex) {
+          goog.asserts.assert(match.segmentIndex,
+              'stream should have a segmentIndex.');
+          outputStream.segmentIndex.appendSegmentIndex(match.segmentIndex);
+        }
+      }
+    }
   }
 
   /**
@@ -679,7 +698,7 @@ shaka.util.PeriodCombiner = class {
    * @param {!Array.<!Set.<T>>} unusedStreamsPerPeriod An array of sets of
    *   unused streams from each period.
    *
-   * @return {!Promise.<?T>} A newly-created output Stream, or null if matches
+   * @return {?T} A newly-created output Stream, or null if matches
    *   could not be found.`
    *
    * @template T
@@ -687,35 +706,36 @@ shaka.util.PeriodCombiner = class {
    *
    * @private
    */
-  static async createNewOutputStream_(
+  static createNewOutputStream_(
       stream, streamsPerPeriod, clone, concat, unusedStreamsPerPeriod) {
     // Start by cloning the stream without segments, key IDs, etc.
     const outputStream = clone(stream);
 
     // Find best-matching streams in all periods.
-    const matches = shaka.util.PeriodCombiner.findMatchesInAllPeriods_(
-        streamsPerPeriod, outputStream);
-
-    if (!matches) {
-      // This is not a stream we can build output from, but it may become part
-      // of another output based on another period's stream.
-      return null;
-    }
+    shaka.util.PeriodCombiner.findMatchesInAllPeriods_(streamsPerPeriod,
+        outputStream);
 
     // This only exists where T == Stream.
     if (outputStream.createSegmentIndex) {
+      // Override the createSegmentIndex function of the outputStream.
+      outputStream.createSegmentIndex = async () => {
+        if (!outputStream.segmentIndex) {
+          outputStream.segmentIndex = new shaka.media.MetaSegmentIndex();
+          await shaka.util.PeriodCombiner.extendOutputSegmentIndex_(
+              outputStream, /* firstNewPeriodIndex= */ 0);
+        }
+      };
       // For T == Stream, we need to create all the per-period segment indexes
       // in advance.  concat() will add them to the output's MetaSegmentIndex.
-      await shaka.util.PeriodCombiner.createSegmentIndexes_(matches);
     }
 
-    // Assure the compiler that matches didn't become null during the async
-    // operation above.
-    goog.asserts.assert(matches, 'Matches should be non-null');
-
-    shaka.util.PeriodCombiner.extendOutputStream_(
-        outputStream, matches, /* firstNewPeriodIndex= */ 0, concat,
-        unusedStreamsPerPeriod);
+    if (!outputStream.matchedStreams) {
+      // This is not a stream we can build output from, but it may become part
+      // of another output based on another period's stream.
+      return null;
+    }
+    shaka.util.PeriodCombiner.extendOutputStream_(outputStream,
+        /* firstNewPeriodIndex= */ 0, concat, unusedStreamsPerPeriod);
 
     return outputStream;
   }
@@ -723,7 +743,6 @@ shaka.util.PeriodCombiner = class {
   /**
    * @param {T} outputStream An existing output stream which needs to be
    *   extended into new periods.
-   * @param {!Array.<T>} matches A list of matching Streams from each period.
    * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
    *   represents the first new period that hasn't been processed yet.
    * @param {function(T, T)} concat Concatenate the second stream onto the end
@@ -737,10 +756,15 @@ shaka.util.PeriodCombiner = class {
    * @private
    */
   static extendOutputStream_(
-      outputStream, matches, firstNewPeriodIndex, concat,
-      unusedStreamsPerPeriod) {
+      outputStream, firstNewPeriodIndex, concat, unusedStreamsPerPeriod) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const LanguageUtils = shaka.util.LanguageUtils;
+    const matches = outputStream.matchedStreams;
+
+    // Assure the compiler that matches didn't become null during the async
+    // operation before.
+    goog.asserts.assert(outputStream.matchedStreams,
+        'matchedStreams should be non-null');
 
     // Concatenate the new matches onto the stream, starting at the first new
     // period.
@@ -784,7 +808,23 @@ shaka.util.PeriodCombiner = class {
     // streams that match this output.
     clone.originalId = null;
     clone.createSegmentIndex = () => Promise.resolve();
-    clone.segmentIndex = new shaka.media.MetaSegmentIndex();
+    clone.closeSegmentIndex = () => {
+      if (clone.segmentIndex) {
+        clone.segmentIndex.release();
+        clone.segmentIndex = null;
+      }
+      // Close the segment index of the matched streams.
+      if (clone.matchedStreams) {
+        for (const match of clone.matchedStreams) {
+          if (match.segmentIndex) {
+            match.segmentIndex.release();
+            match.segmentIndex = null;
+          }
+        }
+      }
+    };
+
+    clone.segmentIndex = null;
     clone.emsgSchemeIdUris = [];
     clone.keyIds = new Set();
     clone.closedCaptions = null;
@@ -870,26 +910,24 @@ shaka.util.PeriodCombiner = class {
       }
     }
 
-    // Satisfy the compiler about the type.
-    goog.asserts.assert(
-        output.segmentIndex instanceof shaka.media.MetaSegmentIndex,
-        'Output streams should have a MetaSegmentIndex!');
-    // Satisfy the compiler that the input index has been created.
-    goog.asserts.assert(
-        input.segmentIndex,
-        'Input segment index should have been created by now!');
-
-    output.segmentIndex.appendSegmentIndex(input.segmentIndex);
-
     // Combine trick-play video streams, if present.
     if (input.trickModeVideo) {
       if (!output.trickModeVideo) {
         // Create a fresh output stream for trick-mode playback.
         output.trickModeVideo = shaka.util.PeriodCombiner.cloneStream_(
             input.trickModeVideo);
-        // Start it with whatever non-trick-mode Streams are in the output so
-        // far.
-        output.trickModeVideo.segmentIndex = output.segmentIndex.clone();
+        // TODO: fix the createSegmentIndex function for trickModeVideo.
+        // The trick-mode tracks in multi-period content should have trick-mode
+        // segment indexes whenever available, rather than only regular-mode
+        // segment indexes.
+        output.trickModeVideo.createSegmentIndex = () => {
+          // Satisfy the compiler about the type.
+          goog.asserts.assert(
+              output.segmentIndex instanceof shaka.media.MetaSegmentIndex,
+              'The stream should have a MetaSegmentIndex.');
+          output.trickModeVideo.segmentIndex = output.segmentIndex.clone();
+          return Promise.resolve();
+        };
       }
 
       // Concatenate the trick mode input onto the trick mode output.
@@ -940,7 +978,6 @@ shaka.util.PeriodCombiner = class {
    *
    * @param {!Array.<!Array.<T>>} streamsPerPeriod
    * @param {T} outputStream
-   * @return {Array.<T>}
    *
    * @template T
    * Accepts either a StreamDB or Stream type.
@@ -953,11 +990,11 @@ shaka.util.PeriodCombiner = class {
       const match = shaka.util.PeriodCombiner.findBestMatchInPeriod_(
           streams, outputStream);
       if (!match) {
-        return null;
+        return;
       }
       matches.push(match);
     }
-    return matches;
+    outputStream.matchedStreams = matches;
   }
 
   /**

package/lib/util/platform.js

@@ -163,7 +163,6 @@ shaka.util.Platform = class {
            !shaka.util.Platform.isEdge();
   }
 
-
   /**
    * Check if the current platform is from Apple.
    *
@@ -179,6 +178,19 @@ shaka.util.Platform = class {
             && !shaka.util.Platform.isTizen();
   }
 
+  /**
+   * Check if the current platform is Playstation 5.
+   *
+   * Returns true on Playstation 5 browsers.
+   *
+   * Returns false for Playstation 5 browsers
+   *
+   * @return {boolean}
+   */
+  static isPS5() {
+    return shaka.util.Platform.userAgentContains_('PlayStation 5');
+  }
+
   /**
    * Returns a major version number for Safari, or Safari-based iOS browsers.
    *

package/lib/util/player_configuration.js

@@ -120,6 +120,8 @@ shaka.util.PlayerConfiguration = class {
         ignoreTextStreamFailures: false,
         ignoreImageStreamFailures: false,
         useFullSegmentsForStartTime: false,
+        defaultAudioCodec: 'mp4a.40.2',
+        defaultVideoCodec: 'avc1.42E01E',
       },
     };
 
@@ -163,6 +165,8 @@ shaka.util.PlayerConfiguration = class {
       forceHTTPS: false,
       preferNativeHls: false,
       updateIntervalSeconds: 1,
+      dispatchAllEmsgBoxes: false,
+      observeQualityChanges: false,
     };
 
     // Some browsers will stop earlier than others before a gap (e.g., Edge
@@ -235,6 +239,19 @@ shaka.util.PlayerConfiguration = class {
         minBandwidth: 0,
         maxBandwidth: Infinity,
       },
+      advanced: {
+        minTotalBytes: 128e3,
+        minBytes: 16e3,
+        fastHalfLife: 2,
+        slowHalfLife: 5,
+      },
+    };
+
+    const cmcd = {
+      enabled: false,
+      sessionId: '',
+      contentId: '',
+      useHeaders: false,
     };
 
     /** @type {shaka.extern.PlayerConfiguration} */
@@ -269,6 +286,7 @@ shaka.util.PlayerConfiguration = class {
       playRangeStart: 0,
       playRangeEnd: Infinity,
       textDisplayFactory: () => null,
+      cmcd: cmcd,
     };
 
     // Add this callback so that we can reference the preferred audio language