shaka-player 4.1.3 → 4.1.5

package/docs/jsdoc-template/publish.js

@@ -440,6 +440,7 @@ function buildNav(members) {
       [members.externals, 'Externals', seen, linktoExternal],
       [members.namespaces, 'Namespaces', seen, linkto],
       [members.classes, 'Classes', seen, linkto],
+      [members.enums, 'Enums', seen, linkto],
       [members.interfaces, 'Interfaces', seen, linkto],
       [members.events, 'Events', seen, linkto],
       [members.mixins, 'Mixins', seen, linkto],
@@ -484,6 +485,7 @@ function fixUpType(type) {
 exports.publish = (taffyData, opts, tutorials) => {
     let classes;
     let conf;
+    let enums;
     let externals;
     let files;
     let fromDir;
@@ -733,6 +735,31 @@ exports.publish = (taffyData, opts, tutorials) => {
     });
 
     members = helper.getMembers(data);
+    members.enums = [];
+
+    data().each(doclet => {
+        if (doclet.isEnum) {
+            const hasParent = !!docletMap[doclet.memberof];
+
+            // Enums without parents (not attached to a class, but directly to a
+            // namespace) aren't recognized by jsdoc by default and need to be
+            // massaged into the docs separately.
+            if (!hasParent) {
+                // Temporarily call this a "class", so that we can fix the URL.
+                doclet.kind = 'class';
+                // Regenerate the URL, so that this enum gets its own page
+                // instead of a URL that links to an ID within a non-existent
+                // parent page.
+                delete helper.longnameToUrl[doclet.longname];
+                helper.createLink(doclet);
+                // Mark this as an enum (custom type), so that it doesn't get
+                // slotted with the classes.
+                doclet.kind = 'enum';
+                members.enums.push(doclet);
+            }
+        }
+    });
+
     members.tutorials = tutorials.children;
     if (conf.default.sortTutorialsByConfigOrder) {
         members.tutorials.sort((a, b) => {
@@ -778,6 +805,7 @@ exports.publish = (taffyData, opts, tutorials) => {
 
     // set up the lists that we'll use to generate pages
     classes = taffy(members.classes);
+    enums = taffy(members.enums);
     modules = taffy(members.modules);
     namespaces = taffy(members.namespaces);
     mixins = taffy(members.mixins);
@@ -786,6 +814,7 @@ exports.publish = (taffyData, opts, tutorials) => {
 
     Object.keys(helper.longnameToUrl).forEach(longname => {
         const myClasses = helper.find(classes, {longname: longname});
+        const myEnums = helper.find(enums, {longname: longname});
         const myExternals = helper.find(externals, {longname: longname});
         const myInterfaces = helper.find(interfaces, {longname: longname});
         const myMixins = helper.find(mixins, {longname: longname});
@@ -800,6 +829,10 @@ exports.publish = (taffyData, opts, tutorials) => {
             generate(`Class: ${myClasses[0].longname}`, myClasses, helper.longnameToUrl[longname]);
         }
 
+        if (myEnums.length) {
+            generate(`Enum: ${myEnums[0].longname}`, myEnums, helper.longnameToUrl[longname]);
+        }
+
         if (myNamespaces.length) {
             generate(`Namespace: ${myNamespaces[0].longname}`, myNamespaces, helper.longnameToUrl[longname]);
         }

package/docs/jsdoc-template/tmpl/container.tmpl

@@ -144,7 +144,10 @@
                 return m.longname && m.longname.indexOf('module:') !== 0;
             });
         }
-        if (members && members.length && members.forEach) {
+
+        // Skip enums, since they already have their values listed under
+        // "Properties".
+        if (members && members.length && members.forEach && doc.kind != 'enum') {
     ?>
         <h3 class="subsection-title">Members</h3>
 

package/docs/jsdoc.conf.json

@@ -16,6 +16,7 @@
       "navOrder": [
         "Tutorials",
         "Classes",
+        "Enums",
         "Interfaces",
         "Events"
       ]

package/externs/shaka/manifest_parser.js

@@ -111,7 +111,8 @@ shaka.extern.ManifestParser = class {
  *   onError: function(!shaka.util.Error),
  *   isLowLatencyMode: function():boolean,
  *   isAutoLowLatencyMode: function():boolean,
- *   enableLowLatencyMode: function()
+ *   enableLowLatencyMode: function(),
+ *   updateDuration: function()
  * }}
  *
  * @description
@@ -147,6 +148,8 @@ shaka.extern.ManifestParser = class {
  *   Return true if auto low latency streaming mode is enabled.
  * @property {function()} enableLowLatencyMode
  *   Enable low latency streaming mode.
+ * @property {function()} updateDuration
+ *   Update the presentation duration based on PresentationTimeline.
  * @exportDoc
  */
 shaka.extern.ManifestParser.PlayerInterface;

package/externs/shaka/player.js

@@ -632,7 +632,8 @@ shaka.extern.AdvancedDrmConfiguration;
  *   logLicenseExchange: boolean,
  *   updateExpirationTime: number,
  *   preferredKeySystems: !Array.<string>,
- *   keySystemsMapping: !Object.<string, string>
+ *   keySystemsMapping: !Object.<string, string>,
+ *   parseInbandPsshEnabled: boolean
  * }}
  *
  * @property {shaka.extern.RetryParameters} retryParameters
@@ -675,6 +676,11 @@ shaka.extern.AdvancedDrmConfiguration;
  *   Specifies the priorties of available DRM key systems.
  * @property {Object.<string, string>} keySystemsMapping
  *   A map of key system name to key system name.
+ * @property {boolean} parseInbandPsshEnabled
+ *   <i>Defaults to true on Xbox One, and false for all other browsers.</i><br>
+ *   When true parse DRM init data from pssh boxes in media and init segments
+ *   and ignore 'encrypted' events.
+ *   This is required when using in-band key rotation on Xbox One.
  *
  * @exportDoc
  */

package/lib/ads/client_side_ad_manager.js

@@ -205,6 +205,13 @@ shaka.ads.ClientSideAdManager = class {
               this.video_.offsetHeight, viewMode);
         });
         this.resizeObserver_.observe(this.video_);
+      } else {
+        this.eventManager_.listen(document, 'fullscreenchange', () => {
+          const viewMode = this.isFullScreenEnabled_() ?
+              google.ima.ViewMode.FULLSCREEN : google.ima.ViewMode.NORMAL;
+          this.imaAdsManager_.resize(this.video_.offsetWidth,
+              this.video_.offsetHeight, viewMode);
+        });
       }
 
       // Single video and overlay ads will start at this time

package/lib/cast/cast_sender.js

@@ -192,21 +192,14 @@ shaka.cast.CastSender = class {
       // If the API becomes available before this instance dies, init will be
       // called again.
 
-      // A note about this value: In our testing environment, we load both
-      // uncompiled and compiled code.  This global callback in uncompiled mode
-      // can be overwritten by the same in compiled mode.  The two versions will
-      // each have their own instances_ map.  Therefore the callback must have a
-      // name, as opposed to being anonymous.  This way, the CastSender tests
-      // can invoke the named static method instead of using a global that could
-      // be overwritten.
-      if (!window.__onGCastApiAvailable) {
-        window.__onGCastApiAvailable = shaka.cast.CastSender.onSdkLoaded_;
-      }
-      if (window.__onGCastApiAvailable != shaka.cast.CastSender.onSdkLoaded_) {
-        shaka.log.alwaysWarn('A global Cast SDK hook is already installed! ' +
-          'Shaka Player will be unable to receive a notification when the ' +
-          'Cast SDK is ready.');
+      // Check if our callback is already installed.
+      if (window.__onGCastApiAvailable !== CastSender.onGCastApiAvailable_) {
+        // Save pre-existing __onGCastApiAvailable in order to restore later.
+        CastSender.__onGCastApiAvailable_ =
+          window.__onGCastApiAvailable || null;
+        window.__onGCastApiAvailable = CastSender.onGCastApiAvailable_;
       }
+
       return;
     }
 
@@ -757,6 +750,9 @@ shaka.cast.CastSender.hasReceivers_ = false;
 /** @private {chrome.cast.Session} */
 shaka.cast.CastSender.session_ = null;
 
+/** @private {?function(boolean)} */
+shaka.cast.CastSender.__onGCastApiAvailable_ = null;
+
 /**
  * A set of all living CastSender instances.  The constructor and destroy
  * methods will add and remove instances from this set.
@@ -784,3 +780,32 @@ shaka.cast.CastSender.onSdkLoaded_ = (loaded) => {
     }
   }
 };
+
+/**
+ * @param {boolean} available
+ * @private
+ */
+shaka.cast.CastSender.onGCastApiAvailable_ = (available) => {
+  // Restore callback from saved.
+  if (shaka.cast.CastSender.__onGCastApiAvailable_) {
+    window.__onGCastApiAvailable =
+      shaka.cast.CastSender.__onGCastApiAvailable_;
+  } else {
+    delete window.__onGCastApiAvailable;
+  }
+  shaka.cast.CastSender.__onGCastApiAvailable_ = null;
+
+  // A note about this value: In our testing environment, we load both
+  // uncompiled and compiled code.  This global callback in uncompiled mode
+  // can be overwritten by the same in compiled mode.  The two versions will
+  // each have their own instances_ map.  Therefore the callback must have a
+  // name, as opposed to being anonymous.  This way, the CastSender tests
+  // can invoke the named static method instead of using a global that could
+  // be overwritten.
+  shaka.cast.CastSender.onSdkLoaded_(available);
+
+  // call restored callback (if any)
+  if (typeof window.__onGCastApiAvailable === 'function') {
+    window.__onGCastApiAvailable(available);
+  }
+};

package/lib/cea/cea608_memory.js

@@ -184,6 +184,10 @@ shaka.cea.Cea608Memory = class {
    * @param {number} count Count of rows to move.
    */
   moveRows(dst, src, count) {
+    if (src < 0 || dst < 0) {
+      return;
+    }
+
     if (dst >= src) {
       for (let i = count-1; i >= 0; i--) {
         this.rows_[dst + i] = this.rows_[src + i].map((e) => e);

package/lib/hls/hls_parser.js

@@ -287,6 +287,21 @@ shaka.hls.HlsParser = class {
     }
 
     await Promise.all(updates);
+
+    this.notifySegments_();
+
+    // If any hasEndList is false, the stream is still live.
+    const stillLive = streamInfos.some((s) => s.hasEndList == false);
+    if (!stillLive) {
+      // Convert the presentation to VOD and set the duration.
+      const PresentationType = shaka.hls.HlsParser.PresentationType_;
+      this.setPresentationType_(PresentationType.VOD);
+
+      const maxTimestamps = streamInfos.map((s) => s.maxTimestamp);
+      // The duration is the minimum of the end times of all streams.
+      this.presentationTimeline_.setDuration(Math.min(...maxTimestamps));
+      this.playerInterface_.updateDuration();
+    }
   }
 
   /**
@@ -297,7 +312,6 @@ shaka.hls.HlsParser = class {
    * @private
    */
   async updateStream_(streamInfo) {
-    const PresentationType = shaka.hls.HlsParser.PresentationType_;
     const manifestUri = streamInfo.absoluteMediaPlaylistUri;
     const uriObj = new goog.Uri(manifestUri);
     if (this.lowLatencyMode_ && streamInfo.canSkipSegments) {
@@ -330,6 +344,7 @@ shaka.hls.HlsParser = class {
         streamInfo.verbatimMediaPlaylistUri, playlist, stream.type,
         stream.mimeType, streamInfo.mediaSequenceToStartTime, mediaVariables,
         stream.codecs);
+    this.segmentsToNotifyByStream_.push(segments);
 
     stream.segmentIndex.mergeAndEvict(
         segments, this.presentationTimeline_.getSegmentAvailabilityStart());
@@ -350,10 +365,10 @@ shaka.hls.HlsParser = class {
         shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
 
     if (endListTag) {
-      // Convert the presentation to VOD and set the duration to the last
-      // segment's end time.
-      this.setPresentationType_(PresentationType.VOD);
-      this.presentationTimeline_.setDuration(newestSegment.endTime);
+      // Flag this for later.  We don't convert the whole presentation into VOD
+      // until we've seen the ENDLIST tag for all active playlists.
+      streamInfo.hasEndList = true;
+      streamInfo.maxTimestamp = newestSegment.endTime;
     }
   }
 
@@ -1761,6 +1776,7 @@ shaka.hls.HlsParser = class {
       maxTimestamp: lastEndTime,
       mediaSequenceToStartTime,
       canSkipSegments,
+      hasEndList: false,
     };
   }
 
@@ -2523,8 +2539,11 @@ shaka.hls.HlsParser = class {
     try {
       await this.update();
 
-      const delay = this.updatePlaylistDelay_;
-      this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
+      // This may have converted to VOD, in which case we stop updating.
+      if (this.isLive_()) {
+        const delay = this.updatePlaylistDelay_;
+        this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
+      }
     } catch (error) {
       // Detect a call to stop() during this.update()
       if (!this.playerInterface_) {
@@ -2707,7 +2726,8 @@ shaka.hls.HlsParser = class {
  *   absoluteMediaPlaylistUri: string,
  *   maxTimestamp: number,
  *   mediaSequenceToStartTime: !Map.<number, number>,
- *   canSkipSegments: boolean
+ *   canSkipSegments: boolean,
+ *   hasEndList: boolean
  * }}
  *
  * @description
@@ -2730,6 +2750,8 @@ shaka.hls.HlsParser = class {
  * @property {boolean} canSkipSegments
  *  True if the server supports delta playlist updates, and we can send a
  *  request for a playlist that can skip older media segments.
+ * @property {boolean} hasEndList
+ *  True if the stream has an EXT-X-ENDLIST tag.
  */
 shaka.hls.HlsParser.StreamInfo;
 

package/lib/media/drm_engine.js

@@ -18,9 +18,11 @@ goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Iterables');
 goog.require('shaka.util.Lazy');
+goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MapUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Platform');
+goog.require('shaka.util.Pssh');
 goog.require('shaka.util.PublicPromise');
 goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.StringUtils');
@@ -497,7 +499,11 @@ shaka.media.DrmEngine = class {
 
     // Explicit init data for any one stream or an offline session is
     // sufficient to suppress 'encrypted' events for all streams.
-    if (!manifestInitData && !this.offlineSessionIds_.length) {
+    // Also suppress 'encrypted' events when parsing in-band ppsh
+    // from media segments because that serves the same purpose as the
+    // 'encrypted' events.
+    if (!manifestInitData && !this.offlineSessionIds_.length &&
+        !this.config_.parseInbandPsshEnabled) {
       this.eventManager_.listen(
           this.video_, 'encrypted', (e) => this.onEncryptedEvent_(e));
     }
@@ -668,6 +674,14 @@ shaka.media.DrmEngine = class {
       }
     }
 
+    // If there are pre-existing sessions that have all been loaded
+    // then reset the allSessionsLoaded_ promise, which can now be
+    // used to wait for new sesssions to be loaded
+    if (this.activeSessions_.size > 0 && this.areAllSessionsLoaded_()) {
+      this.allSessionsLoaded_.resolve();
+      this.allSessionsLoaded_ = new shaka.util.PublicPromise();
+      this.allSessionsLoaded_.catch(() => {});
+    }
     this.createSession(initDataType, initData,
         this.currentDrmInfo_.sessionType);
   }
@@ -2329,6 +2343,43 @@ shaka.media.DrmEngine = class {
       }
     }
   }
+
+  /**
+   * Parse  pssh from a media segment and announce new initData
+   *
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {!BufferSource} mediaSegment
+   * @return {!Promise<void>}
+   */
+  parseInbandPssh(contentType, mediaSegment) {
+    if (!this.config_.parseInbandPsshEnabled) {
+      return Promise.resolve();
+    }
+
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    if (![ContentType.AUDIO, ContentType.VIDEO].includes(contentType)) {
+      return Promise.resolve();
+    }
+
+    const pssh = new shaka.util.Pssh(
+        shaka.util.BufferUtils.toUint8(mediaSegment));
+
+    let totalLength = 0;
+    for (const data of pssh.data) {
+      totalLength += data.length;
+    }
+    if (totalLength == 0) {
+      return Promise.resolve();
+    }
+    const combinedData = new Uint8Array(totalLength);
+    let pos = 0;
+    for (const data of pssh.data) {
+      combinedData.set(data, pos);
+      pos += data.length;
+    }
+    this.newInitData('cenc', combinedData);
+    return this.allSessionsLoaded_;
+  }
 };
 
 

package/lib/media/media_source_engine.js

@@ -522,9 +522,13 @@ shaka.media.MediaSourceEngine = class {
    * @param {?boolean} hasClosedCaptions True if the buffer contains CEA closed
    *   captions
    * @param {boolean=} seeked True if we just seeked
+   * @param {boolean=} adaptation True if we just automatically switched active
+   *   variant(s).
    * @return {!Promise}
    */
-  async appendBuffer(contentType, data, reference, hasClosedCaptions, seeked) {
+  async appendBuffer(
+      contentType, data, reference, hasClosedCaptions, seeked = false,
+      adaptation = false) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     if (contentType == ContentType.TEXT) {
@@ -625,6 +629,14 @@ shaka.media.MediaSourceEngine = class {
 
         await this.enqueueOperation_(
             contentType, () => this.append_(contentType, data));
+        // If the input buffer passed to SourceBuffer#appendBuffer() does not
+        // contain a complete media segment, the call will exit while the
+        // SourceBuffer's append state is
+        // still PARSING_MEDIA_SEGMENT. Reset the parser state by calling
+        // abort() to safely reset timestampOffset to 'originalOffset'.
+        // https://www.w3.org/TR/media-source-2/#sourcebuffer-segment-parser-loop
+        await this.enqueueOperation_(
+            contentType, () => this.abort_(contentType));
 
         // Reset the offset and append window.
         sourceBuffer.timestampOffset = originalOffset;
@@ -638,10 +650,17 @@ shaka.media.MediaSourceEngine = class {
         const textOffset = (reference.startTime || 0) - (mediaStartTime || 0);
         this.textSequenceModeOffset_.resolve(textOffset);
 
-        // Finally, clear the buffer.
+        // Clear the buffer.
         await this.enqueueOperation_(
             contentType,
             () => this.remove_(contentType, 0, this.mediaSource_.duration));
+
+        // Finally, flush the buffer in case of choppy video start on HLS fMP4.
+        if (contentType == ContentType.VIDEO) {
+          await this.enqueueOperation_(
+              contentType,
+              () => this.flush_(contentType));
+        }
       }
 
       // Now switch to sequence mode and fall through to our normal operations.
@@ -650,10 +669,15 @@ shaka.media.MediaSourceEngine = class {
 
     if (reference && this.sequenceMode_ && contentType != ContentType.TEXT) {
       // In sequence mode, for non-text streams, if we just cleared the buffer
-      // and are performing an unbuffered seek, we need to set a new
-      // timestampOffset on the sourceBuffer.
-      if (seeked) {
+      // and are either performing an unbuffered seek or handling an automatic
+      // adaptation, we need to set a new timestampOffset on the sourceBuffer.
+      if (seeked || adaptation) {
         const timestampOffset = reference.startTime;
+        // The logic to call abort() before setting the timestampOffset is
+        // extended during unbuffered seeks or automatic adaptations; it is
+        // possible for the append state to be PARSING_MEDIA_SEGMENT from the
+        // previous SourceBuffer#appendBuffer() call.
+        this.enqueueOperation_(contentType, () => this.abort_(contentType));
         this.enqueueOperation_(
             contentType,
             () => this.setTimestampOffset_(contentType, timestampOffset));
@@ -849,21 +873,25 @@ shaka.media.MediaSourceEngine = class {
   }
 
   /**
-   * We only support increasing duration at this time.  Decreasing duration
-   * causes the MSE removal algorithm to run, which results in an 'updateend'
-   * event.  Supporting this scenario would be complicated, and is not currently
-   * needed.
-   *
    * @param {number} duration
    * @return {!Promise}
    */
   async setDuration(duration) {
-    goog.asserts.assert(
-        isNaN(this.mediaSource_.duration) ||
-            this.mediaSource_.duration <= duration,
-        'duration cannot decrease: ' + this.mediaSource_.duration + ' -> ' +
-            duration);
     await this.enqueueBlockingOperation_(() => {
+      // Reducing the duration causes the MSE removal algorithm to run, which
+      // triggers an 'updateend' event to fire.  To handle this scenario, we
+      // have to insert a dummy operation into the beginning of each queue,
+      // which the 'updateend' handler will remove.
+      if (duration < this.mediaSource_.duration) {
+        for (const contentType in this.sourceBuffers_) {
+          const dummyOperation = {
+            start: () => {},
+            p: new shaka.util.PublicPromise(),
+          };
+          this.queues_[contentType].unshift(dummyOperation);
+        }
+      }
+
       this.mediaSource_.duration = duration;
     });
   }