shaka-player 4.5.0 → 4.6.0

package/lib/util/content_steering_manager.js

@@ -0,0 +1,358 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.util.ContentSteeringManager');
+
+goog.require('goog.Uri');
+goog.require('shaka.media.ManifestParser');
+goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.util.Error');
+goog.require('shaka.util.IDestroyable');
+goog.require('shaka.util.ManifestParserUtils');
+goog.require('shaka.util.OperationManager');
+goog.require('shaka.util.StringUtils');
+goog.require('shaka.util.Timer');
+
+
+/**
+ * Create a Content Steering manager.
+ *
+ * @implements {shaka.util.IDestroyable}
+ */
+shaka.util.ContentSteeringManager = class {
+  /**
+   * @param {shaka.extern.ManifestParser.PlayerInterface} playerInterface
+   */
+  constructor(playerInterface) {
+    /** @private {?shaka.extern.ManifestConfiguration} */
+    this.config_ = null;
+
+    /** @private {?shaka.extern.ManifestParser.PlayerInterface} */
+    this.playerInterface_ = playerInterface;
+
+    /** @private {!shaka.util.OperationManager} */
+    this.operationManager_ = new shaka.util.OperationManager();
+
+    /** @private {!Array.<string>} */
+    this.baseUris_ = [];
+
+    /** @private {?string} */
+    this.defaultPathwayId_ = null;
+
+    /** @private {!Array.<string>} */
+    this.pathwayPriority_ = [];
+
+    /** @private {?string} */
+    this.lastPathwayUsed_ = null;
+
+    /** @private {!Array.<shaka.util.ContentSteeringManager.PathawayClone>} */
+    this.pathwayClones_ = [];
+
+    /**
+     * Default to 5 minutes. Value in seconds.
+     *
+     * @private {number}
+     */
+    this.lastTTL_ = 300;
+
+    /** @private {!Map.<(string|number), !Map.<string, string>>} */
+    this.locations_ = new Map();
+
+    /** @private {!Map.<string, number>} */
+    this.bannedLocations_ = new Map();
+
+    /** @private {?shaka.util.Timer} */
+    this.updateTimer_ = null;
+
+    /** @private {string} */
+    this.manifestType_ = shaka.media.ManifestParser.UNKNOWN;
+  }
+
+  /**
+   * @param {shaka.extern.ManifestConfiguration} config
+   */
+  configure(config) {
+    this.config_ = config;
+  }
+
+
+  /** @override */
+  destroy() {
+    this.config_ = null;
+    this.playerInterface_ = null;
+    this.baseUris_ = [];
+    this.defaultPathwayId_ = null;
+    this.pathwayPriority_ = [];
+    this.pathwayClones_ = [];
+    this.locations_.clear();
+
+    if (this.updateTimer_ != null) {
+      this.updateTimer_.stop();
+      this.updateTimer_ = null;
+    }
+
+    return this.operationManager_.destroy();
+  }
+
+  /**
+   * @param {string} manifestType
+   */
+  setManifestType(manifestType) {
+    this.manifestType_ = manifestType;
+  }
+
+  /**
+   * @param {!Array.<string>} baseUris
+   */
+  setBaseUris(baseUris) {
+    this.baseUris_ = baseUris;
+  }
+
+  /**
+   * @param {?string} defaultPathwayId
+   */
+  setDefaultPathwayId(defaultPathwayId) {
+    this.defaultPathwayId_ = defaultPathwayId;
+  }
+
+  /**
+   * Request the Content Steering info.
+   *
+   * @param {string} uri
+   * @return {!Promise}
+   */
+  async requestInfo(uri) {
+    const uris = shaka.util.ManifestParserUtils.resolveUris(
+        this.baseUris_, [this.addQueryParams_(uri)]);
+    const type = shaka.net.NetworkingEngine.RequestType.CONTENT_STEERING;
+    const request = shaka.net.NetworkingEngine.makeRequest(
+        uris, this.config_.retryParameters);
+
+    const op = this.playerInterface_.networkingEngine.request(type, request);
+    this.operationManager_.manage(op);
+    try {
+      const response = await op.promise;
+      const str = shaka.util.StringUtils.fromUTF8(response.data);
+      const steeringManifest =
+          /** @type {shaka.util.ContentSteeringManager.SteeringManifest} */
+          (JSON.parse(str));
+      if (steeringManifest.VERSION == 1) {
+        this.processManifest_(steeringManifest, response.uri);
+      }
+    } catch (e) {
+      if (e && e.code == shaka.util.Error.Code.OPERATION_ABORTED) {
+        return;
+      }
+      if (this.updateTimer_ != null) {
+        this.updateTimer_.stop();
+        this.updateTimer_ = null;
+      }
+      this.updateTimer_ = new shaka.util.Timer(() => {
+        this.requestInfo(uri);
+      });
+      this.updateTimer_.tickAfter(this.lastTTL_);
+    }
+  }
+
+  /** @private */
+  addQueryParams_(uri) {
+    if (!this.pathwayPriority_.length) {
+      return uri;
+    }
+    const finalUri = new goog.Uri(uri);
+    const currentPathwayID = this.lastPathwayUsed_ || this.pathwayPriority_[0];
+    const currentBandwidth =
+        Math.round(this.playerInterface_.getBandwidthEstimate());
+    const queryData = finalUri.getQueryData();
+    if (this.manifestType_ == shaka.media.ManifestParser.DASH) {
+      queryData.add('_DASH_pathway', currentPathwayID);
+      queryData.add('_DASH_throughput', String(currentBandwidth));
+    } else if (this.manifestType_ == shaka.media.ManifestParser.HLS) {
+      queryData.add('_HLS_pathway', currentPathwayID);
+      queryData.add('_HLS_throughput', String(currentBandwidth));
+    }
+    if (queryData.getCount()) {
+      finalUri.setQueryData(queryData);
+    }
+    return finalUri.toString();
+  }
+
+  /**
+   * @param {shaka.util.ContentSteeringManager.SteeringManifest} manifest
+   * @param {string} finalManifestUri
+   * @private
+   */
+  processManifest_(manifest, finalManifestUri) {
+    if (this.updateTimer_ != null) {
+      this.updateTimer_.stop();
+      this.updateTimer_ = null;
+    }
+    const uri = manifest['RELOAD-URI'] || finalManifestUri;
+    this.updateTimer_ = new shaka.util.Timer(() => {
+      this.requestInfo(uri);
+    });
+    const newTTL = manifest['TTL'];
+    if (newTTL) {
+      this.lastTTL_ = newTTL;
+    }
+    this.updateTimer_.tickAfter(this.lastTTL_);
+    this.pathwayPriority_ = manifest['PATHWAY-PRIORITY'] || [];
+    this.pathwayClones_ = manifest['PATHWAY-CLONES'] || [];
+  }
+
+  /**
+   * Clear the previous locations added.
+   */
+  clearPreviousLocations() {
+    this.locations_.clear();
+  }
+
+  /**
+   * @param {string|number} streamId
+   * @param {string} pathwayId
+   * @param {string} uri
+   */
+  addLocation(streamId, pathwayId, uri) {
+    let streamLocations = this.locations_.get(streamId);
+    if (!streamLocations) {
+      streamLocations = new Map();
+    }
+    streamLocations.set(pathwayId, uri);
+    this.locations_.set(streamId, streamLocations);
+  }
+
+  /**
+   * @param {string} uri
+   */
+  banLocation(uri) {
+    const bannedUntil = Date.now() + 60000;
+    this.bannedLocations_.set(uri, bannedUntil);
+  }
+
+  /**
+   * Get the base locations ordered according the priority.
+   *
+   * @param {string|number} streamId
+   * @return {!Array.<string>}
+   */
+  getLocations(streamId) {
+    const streamLocations = this.locations_.get(streamId) || new Map();
+    /** @type {!Array.<!{pathwayId: string, location: string}>} */
+    let locationsPathwayIdMap = [];
+    for (const pathwayId of this.pathwayPriority_) {
+      const location = streamLocations.get(pathwayId);
+      if (location) {
+        locationsPathwayIdMap.push({pathwayId, location});
+      } else {
+        const clone = this.pathwayClones_.find((c) => c.ID == pathwayId);
+        if (clone) {
+          const cloneLocation = streamLocations.get(clone['BASE-ID']);
+          if (cloneLocation) {
+            if (clone['URI-REPLACEMENT'].HOST) {
+              const uri = new goog.Uri(cloneLocation);
+              uri.setDomain(clone['URI-REPLACEMENT'].HOST);
+              locationsPathwayIdMap.push({
+                pathwayId: pathwayId,
+                location: uri.toString(),
+              });
+            } else {
+              locationsPathwayIdMap.push({
+                pathwayId: pathwayId,
+                location: cloneLocation,
+              });
+            }
+          }
+        }
+      }
+    }
+
+    const now = Date.now();
+    for (const uri of this.bannedLocations_.keys()) {
+      const bannedUntil = this.bannedLocations_.get(uri);
+      if (now > bannedUntil) {
+        this.bannedLocations_.delete(uri);
+      }
+    }
+    locationsPathwayIdMap = locationsPathwayIdMap.filter((l) => {
+      for (const uri of this.bannedLocations_.keys()) {
+        if (uri.includes(new goog.Uri(l.location).getDomain())) {
+          return false;
+        }
+      }
+      return true;
+    });
+
+    if (locationsPathwayIdMap.length) {
+      this.lastPathwayUsed_ = locationsPathwayIdMap[0].pathwayId;
+    }
+
+    const locations = locationsPathwayIdMap.map((l) => l.location);
+
+    if (!locations.length && this.defaultPathwayId_) {
+      for (const pathwayId of this.defaultPathwayId_.split(',')) {
+        const location = streamLocations.get(pathwayId);
+        if (location) {
+          this.lastPathwayUsed_ = this.defaultPathwayId_;
+          locations.push(location);
+        }
+      }
+    }
+    if (!locations.length) {
+      for (const location of streamLocations.values()) {
+        locations.push(location);
+      }
+    }
+    return shaka.util.ManifestParserUtils.resolveUris(
+        this.baseUris_, locations);
+  }
+};
+
+
+/**
+ * @typedef {{
+ *   VERSION: number,
+ *   TTL: number,
+ *   RELOAD-URI: string,
+ *   PATHWAY-PRIORITY: !Array.<string>,
+ *   PATHWAY-CLONES: !Array.<shaka.util.ContentSteeringManager.PathawayClone>
+ * }}
+ *
+ * @description
+ * Contains information about the Steering Manifest
+ *
+ * @property {string} VERSION
+ * @property {number} TTL
+ * @property {string RELOAD-URI
+ * @property {!Array.<string>} PATHWAY-PRIORITY
+ * @property {!Array.<
+ *            shaka.util.ContentSteeringManager.PathawayClone>} PATHWAY-CLONES
+ */
+shaka.util.ContentSteeringManager.SteeringManifest;
+
+
+/**
+ * @typedef {{
+ *   BASE-ID: string,
+ *   ID: string,
+ *   URI-REPLACEMENT: !Array.<shaka.util.ContentSteeringManager.UriReplacement>
+ * }}
+ *
+ * @property {string} BASE-ID
+ * @property {string} ID
+ * @property {!Array.<
+ *            shaka.util.ContentSteeringManager.UriReplacement>} URI-REPLACEMENT
+ */
+shaka.util.ContentSteeringManager.PathawayClone;
+
+
+/**
+ * @typedef {{
+ *   HOST: string
+ * }}
+ *
+ * @property {string} HOST
+ */
+shaka.util.ContentSteeringManager.UriReplacement;

package/lib/util/error.js

@@ -330,7 +330,7 @@ shaka.util.Error.Code = {
 
   /**
    * Unable to guess mime type of the text.
-   * <br> error.data[0] is the text file's extension.
+   * <br> error.data[0] is the text file's uri.
    */
   'TEXT_COULD_NOT_GUESS_MIME_TYPE': 2011,
 
@@ -360,11 +360,7 @@ shaka.util.Error.Code = {
    */
   'CHAPTERS_TRACK_FAILED': 2015,
 
-  /**
-   * External thumbnails tracks cannot be added in src= because native platform
-   * doesn't support it.
-   */
-  'CANNOT_ADD_EXTERNAL_THUMBNAILS_TO_SRC_EQUALS': 2016,
+  // RETIRED: 'CANNOT_ADD_EXTERNAL_THUMBNAILS_TO_SRC_EQUALS': 2016,
 
   /**
    * Only external urls of WebVTT type are supported.

package/lib/util/fairplay_utils.js

@@ -205,7 +205,7 @@ shaka.util.FairPlayUtils = class {
     const stringToArray = (string) => {
       // 2 bytes for each char
       const buffer = new ArrayBuffer(string.length * 2);
-      const array = new Uint16Array(buffer);
+      const array = shaka.util.BufferUtils.toUint16(buffer);
       for (let i = 0, strLen = string.length; i < strLen; i++) {
         array[i] = string.charCodeAt(i);
       }

package/lib/util/fake_event.js

@@ -156,6 +156,7 @@ shaka.util.FakeEvent.EventName = {
   AbrStatusChanged: 'abrstatuschanged',
   Adaptation: 'adaptation',
   Buffering: 'buffering',
+  Complete: 'complete',
   DownloadFailed: 'downloadfailed',
   DownloadHeadersReceived: 'downloadheadersreceived',
   DrmSessionUpdate: 'drmsessionupdate',
@@ -163,6 +164,7 @@ shaka.util.FakeEvent.EventName = {
   Prft: 'prft',
   Error: 'error',
   ExpirationUpdated: 'expirationupdated',
+  FirstQuartile: 'firstquartile',
   GapJumped: 'gapjumped',
   KeyStatusChanged: 'keystatuschanged',
   Loaded: 'loaded',
@@ -171,16 +173,18 @@ shaka.util.FakeEvent.EventName = {
   ManifestUpdated: 'manifestupdated',
   MediaQualityChanged: 'mediaqualitychanged',
   Metadata: 'metadata',
+  Midpoint: 'midpoint',
   OnStateChange: 'onstatechange',
-  OnStateIdle: 'onstateidle',
   RateChange: 'ratechange',
   SegmentAppended: 'segmentappended',
   SessionDataEvent: 'sessiondata',
   StallDetected: 'stalldetected',
+  Started: 'started',
   StateChanged: 'statechanged',
   Streaming: 'streaming',
   TextChanged: 'textchanged',
   TextTrackVisibility: 'texttrackvisibility',
+  ThirdQuartile: 'thirdquartile',
   TimelineRegionAdded: 'timelineregionadded',
   TimelineRegionEnter: 'timelineregionenter',
   TimelineRegionExit: 'timelineregionexit',

package/lib/util/id3_utils.js

@@ -140,9 +140,58 @@ shaka.util.Id3Utils = class {
       key: frame.type,
       description: '',
       data: '',
+      mimeType: null,
+      pictureType: null,
     };
 
-    if (frame.type === 'TXXX') {
+    if (frame.type === 'APIC') {
+      /*
+       * Format:
+       * [0]       = {Text Encoding}
+       * [1 - X]   = {MIME Type}\0
+       * [X+1]     = {Picture Type}
+       * [X+2 - Y] = {Description}\0
+       * [Y - ?]   = {Picture Data or Picture URL}
+       */
+      if (frame.size < 2) {
+        return null;
+      }
+      if (frame.data[0] !== shaka.util.Id3Utils.UTF8_encoding) {
+        shaka.log.warning('Ignore frame with unrecognized character ' +
+            'encoding');
+        return null;
+      }
+
+      const mimeTypeEndIndex = frame.data.subarray(1).indexOf(0);
+      if (mimeTypeEndIndex === -1) {
+        return null;
+      }
+      const mimeType = StringUtils.fromUTF8(
+          BufferUtils.toUint8(frame.data, 1, mimeTypeEndIndex));
+      const pictureType = frame.data[2 + mimeTypeEndIndex];
+      const descriptionEndIndex = frame.data.subarray(3 + mimeTypeEndIndex)
+          .indexOf(0);
+      if (descriptionEndIndex === -1) {
+        return null;
+      }
+      const description = StringUtils.fromUTF8(
+          BufferUtils.toUint8(frame.data, 3 + mimeTypeEndIndex,
+              descriptionEndIndex));
+      let data;
+      if (mimeType === '-->') {
+        data = StringUtils.fromUTF8(
+            BufferUtils.toUint8(
+                frame.data, 4 + mimeTypeEndIndex + descriptionEndIndex));
+      } else {
+        data = BufferUtils.toArrayBuffer(
+            frame.data.subarray(4 + mimeTypeEndIndex + descriptionEndIndex));
+      }
+      metadataFrame.mimeType = mimeType;
+      metadataFrame.pictureType = pictureType;
+      metadataFrame.description = description;
+      metadataFrame.data = data;
+      return metadataFrame;
+    } else if (frame.type === 'TXXX') {
       /*
        * Format:
        * [0]   = {Text Encoding}

package/lib/util/manifest_parser_utils.js

@@ -8,7 +8,6 @@ goog.provide('shaka.util.ManifestParserUtils');
 
 goog.require('goog.Uri');
 goog.require('shaka.util.Error');
-goog.require('shaka.util.Functional');
 
 
 /**
@@ -27,7 +26,6 @@ shaka.util.ManifestParserUtils = class {
    * @return {!Array.<string>}
    */
   static resolveUris(baseUris, relativeUris) {
-    const Functional = shaka.util.Functional;
     if (relativeUris.length == 0) {
       return baseUris;
     }
@@ -39,12 +37,18 @@ shaka.util.ManifestParserUtils = class {
     }
 
     const relativeAsGoog = relativeUris.map((uri) => new goog.Uri(uri));
-    // Resolve each URI relative to each base URI, creating an Array of Arrays.
-    // Then flatten the Arrays into a single Array.
-    return baseUris.map((uri) => {
-      const base = new goog.Uri(uri);
-      return relativeAsGoog.map((i) => base.resolve(i).toString());
-    }).reduce(Functional.collapseArrays, []);
+
+    // For each base URI, this code resolves it with every relative URI.
+    // The result is a single array containing all the resolved URIs.
+    const resolvedUris = [];
+    for (const baseStr of baseUris) {
+      const base = new goog.Uri(baseStr);
+      for (const relative of relativeAsGoog) {
+        resolvedUris.push(base.resolve(relative).toString());
+      }
+    }
+
+    return resolvedUris;
   }
 
 

package/lib/util/mp4_generator.js

@@ -1037,10 +1037,8 @@ shaka.util.Mp4Generator = class {
   mdat_(streamInfo) {
     const Mp4Generator = shaka.util.Mp4Generator;
     const samples = streamInfo.data ? streamInfo.data.samples : [];
-    let bytes = new Uint8Array([]);
-    for (const sample of samples) {
-      bytes = shaka.util.Uint8ArrayUtils.concat(bytes, sample.data);
-    }
+    const allData = samples.map((sample) => sample.data);
+    const bytes = shaka.util.Uint8ArrayUtils.concat(...allData);
     return Mp4Generator.box('mdat', bytes);
   }
 

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} */