shaka-player 3.3.5 → 4.0.2

package/lib/media/playhead.js

@@ -160,10 +160,8 @@ shaka.media.MediaSourcePlayhead = class {
    * @param {function()} onSeek
    *     Called when the user agent seeks to a time within the presentation
    *     timeline.
-   * @param {function(!Event)} onEvent
-   *     Called when an event is raised to be sent to the application.
    */
-  constructor(mediaElement, manifest, config, startTime, onSeek, onEvent) {
+  constructor(mediaElement, manifest, config, startTime, onSeek) {
     /**
      * The seek range must be at least this number of seconds long. If it is
      * smaller than this, change it to be this big so we don't repeatedly seek
@@ -199,8 +197,7 @@ shaka.media.MediaSourcePlayhead = class {
         mediaElement,
         manifest.presentationTimeline,
         config,
-        this.createStallDetector_(mediaElement, config),
-        onEvent);
+        this.createStallDetector_(mediaElement, config));
 
     /** @private {shaka.media.VideoWrapper} */
     this.videoWrapper_ = new shaka.media.VideoWrapper(

package/lib/media/presentation_timeline.js

@@ -249,8 +249,7 @@ shaka.media.PresentationTimeline = class {
    * @param {number} startTime
    * @export
    */
-  notifyMinSegmentStartTime(
-      startTime) {
+  notifyMinSegmentStartTime(startTime) {
     if (this.minSegmentStartTime_ == null) {
       // No data yet, and Math.min(null, startTime) is always 0.  So just store
       // startTime.

package/lib/media/segment_index.js

@@ -9,7 +9,6 @@ goog.provide('shaka.media.SegmentIndex');
 goog.provide('shaka.media.SegmentIterator');
 
 goog.require('goog.asserts');
-goog.require('shaka.Deprecate');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.Timer');
@@ -52,23 +51,6 @@ shaka.media.SegmentIndex = class {
   }
 
 
-  /**
-   * SegmentIndex used to be an IDestroyable.  Now it is an IReleasable.
-   * This method is provided for backward compatibility.
-   *
-   * @deprecated
-   * @return {!Promise}
-   * @export
-   */
-  destroy() {
-    shaka.Deprecate.deprecateFeature(4,
-        'shaka.media.SegmentIndex',
-        'Please use release() instead of destroy().');
-    this.release();
-    return Promise.resolve();
-  }
-
-
   /**
    * @override
    * @export
@@ -101,6 +83,17 @@ shaka.media.SegmentIndex = class {
   }
 
 
+  /**
+   * Iterates over all top-level segment references in this segment index.
+   * @param {function(!shaka.media.SegmentReference)} fn
+   */
+  forEachTopLevelReference(fn) {
+    for (const reference of this.references) {
+      fn(reference);
+    }
+  }
+
+
   /**
    * Finds the position of the segment for the given time, in seconds, relative
    * to the start of the presentation.  Returns the position of the segment
@@ -191,9 +184,6 @@ shaka.media.SegmentIndex = class {
    * @param {!Array.<!shaka.media.SegmentReference>} references The list of
    *   SegmentReferences, which must be sorted first by their start times
    *   (ascending) and second by their end times (ascending).
-   * @deprecated Not used directly by our own parsers, so will become private in
-   *   v4.  Use mergeAndEvict() instead.
-   * @export
    */
   merge(references) {
     if (goog.DEBUG) {
@@ -348,7 +338,8 @@ shaka.media.SegmentIndex = class {
             lastReference.appendWindowEnd,
             lastReference.partialReferences,
             lastReference.tilesLayout,
-            lastReference.tileDuration);
+            lastReference.tileDuration,
+            lastReference.syncTime);
   }
 
 
@@ -513,30 +504,6 @@ shaka.media.SegmentIterator = class {
     this.currentPartialPosition_ = partialSegmentIndex;
   }
 
-  /**
-   * Move the iterator to a given timestamp in the underlying SegmentIndex.
-   *
-   * @param {number} time
-   * @return {shaka.media.SegmentReference}
-   * @deprecated Use SegmentIndex.getIteratorForTime instead
-   * @export
-   */
-  seek(time) {
-    shaka.Deprecate.deprecateFeature(
-        4, 'shaka.media.SegmentIterator',
-        'Please use SegmentIndex.getIteratorForTime instead of seek().');
-
-    const iter = this.segmentIndex_.getIteratorForTime(time);
-    if (iter) {
-      this.currentPosition_ = iter.currentPosition_;
-      this.currentPartialPosition_ = iter.currentPartialPosition_;
-    } else {
-      this.currentPosition_ = Number.MAX_VALUE;
-      this.currentPartialPosition_ = 0;
-    }
-    return this.next().value;
-  }
-
   /**
    * @return {shaka.media.SegmentReference}
    * @export

package/lib/media/segment_reference.js

@@ -159,11 +159,18 @@ shaka.media.SegmentReference = class {
    *  The explicit duration of an individual tile within the tiles grid.
    *  If not provided, the duration should be automatically calculated based on
    *  the duration of the reference.
+   * @param {?number=} syncTime
+   *  A time value, expressed in the same scale as the start and end time, which
+   *  is used to synchronize between streams.
+   * @param {shaka.media.SegmentReference.Status=} status
+   *  The segment status is used to indicate that a segment does not exist or is
+   *  not available.
    */
   constructor(
       startTime, endTime, uris, startByte, endByte, initSegmentReference,
       timestampOffset, appendWindowStart, appendWindowEnd,
-      partialReferences = [], tilesLayout = '', tileDuration = null) {
+      partialReferences = [], tilesLayout = '', tileDuration = null,
+      syncTime = null, status = shaka.media.SegmentReference.Status.AVAILABLE) {
     // A preload hinted Partial Segment has the same startTime and endTime.
     goog.asserts.assert(startTime <= endTime,
         'startTime must be less than or equal to endTime');
@@ -213,6 +220,12 @@ shaka.media.SegmentReference = class {
 
     /** @type {?number} */
     this.tileDuration = tileDuration;
+
+    /** @type {?number} */
+    this.syncTime = syncTime;
+
+    /** @type {shaka.media.SegmentReference.Status} */
+    this.status = status;
   }
 
   /**
@@ -308,6 +321,39 @@ shaka.media.SegmentReference = class {
   getTileDuration() {
     return this.tileDuration;
   }
+
+  /**
+   * Returns the segment's status.
+   *
+   * @return {shaka.media.SegmentReference.Status}
+   * @export
+   */
+  getStatus() {
+    return this.status;
+  }
+
+  /**
+   * Mark the reference as unavailable.
+   *
+   * @export
+   */
+  markAsUnavailable() {
+    this.status = shaka.media.SegmentReference.Status.UNAVAILABLE;
+  }
+};
+
+
+/**
+ * Rather than using booleans to communicate what the state of the reference,
+ * we have this enum.
+ *
+ * @enum {number}
+ * @export
+ */
+shaka.media.SegmentReference.Status = {
+  AVAILABLE: 0,
+  UNAVAILABLE: 1,
+  MISSING: 2,
 };
 
 

package/lib/media/streaming_engine.js

@@ -234,7 +234,8 @@ shaka.media.StreamingEngine = class {
 
     const mimeType = shaka.util.MimeUtils.getFullType(
         stream.mimeType, stream.codecs);
-    this.playerInterface_.mediaSourceEngine.reinitText(mimeType);
+    this.playerInterface_.mediaSourceEngine.reinitText(
+        mimeType, this.manifest_.sequenceMode);
 
     const textDisplayer =
         this.playerInterface_.mediaSourceEngine.getTextDisplayer();
@@ -428,7 +429,8 @@ shaka.media.StreamingEngine = class {
       // init segment again.
       const fullMimeType = shaka.util.MimeUtils.getFullType(
           stream.mimeType, stream.codecs);
-      this.playerInterface_.mediaSourceEngine.reinitText(fullMimeType);
+      this.playerInterface_.mediaSourceEngine.reinitText(
+          fullMimeType, this.manifest_.sequenceMode);
     }
 
     // Releases the segmentIndex of the old stream.
@@ -604,11 +606,10 @@ shaka.media.StreamingEngine = class {
    */
   seeked() {
     const presentationTime = this.playerInterface_.getPresentationTime();
-    const smallGapLimit = this.config_.smallGapLimit;
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const newTimeIsBuffered = (type) => {
       return this.playerInterface_.mediaSourceEngine.isBuffered(
-          type, presentationTime, smallGapLimit);
+          type, presentationTime);
     };
 
     let streamCleared = false;
@@ -645,6 +646,10 @@ shaka.media.StreamingEngine = class {
         if (type === ContentType.TEXT) {
           this.playerInterface_.mediaSourceEngine.resetCaptionParser();
         }
+
+        // Mark the media state as having seeked, so that the new buffers know
+        // that they will need to be at a new position (for sequence mode).
+        mediaState.seeked = true;
       }
     }
 
@@ -764,7 +769,9 @@ shaka.media.StreamingEngine = class {
     const mediaSourceEngine = this.playerInterface_.mediaSourceEngine;
     const forceTransmuxTS = this.config_.forceTransmuxTS;
 
-    await mediaSourceEngine.init(streamsByType, forceTransmuxTS);
+
+    await mediaSourceEngine.init(streamsByType, forceTransmuxTS,
+        this.manifest_.sequenceMode);
     this.destroyer_.ensureNotDestroyed();
 
     this.setDuration_();
@@ -805,6 +812,9 @@ shaka.media.StreamingEngine = class {
       clearBufferSafeMargin: 0,
       waitingToFlushBuffer: false,
       clearingBuffer: false,
+      // The playhead might be seeking on startup, if a start time is set, so
+      // start "seeked" as true.
+      seeked: true,
       recovering: false,
       hasError: false,
       operation: null,
@@ -1272,6 +1282,7 @@ shaka.media.StreamingEngine = class {
           this.scheduleUpdate_(mediaState, 0);
           return;
         }
+
         await this.append_(
             mediaState, presentationTime, stream, reference, result);
       }
@@ -1508,7 +1519,7 @@ shaka.media.StreamingEngine = class {
 
           await this.playerInterface_.mediaSourceEngine.setStreamProperties(
               mediaState.type, timestampOffset, appendWindowStart,
-              appendWindowEnd);
+              appendWindowEnd, this.manifest_.sequenceMode);
         } catch (error) {
           mediaState.lastAppendWindowStart = null;
           mediaState.lastAppendWindowEnd = null;
@@ -1565,8 +1576,7 @@ shaka.media.StreamingEngine = class {
    * @return {!Promise}
    * @private
    */
-  async append_(mediaState, presentationTime, stream, reference,
-      segment) {
+  async append_(mediaState, presentationTime, stream, reference, segment) {
     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
 
     const hasClosedCaptions = stream.closedCaptions &&
@@ -1584,14 +1594,18 @@ shaka.media.StreamingEngine = class {
 
     await this.evict_(mediaState, presentationTime);
     this.destroyer_.ensureNotDestroyed();
-    shaka.log.v1(logPrefix, 'appending media segment');
+    shaka.log.v1(logPrefix, 'appending media segment at',
+        (reference.syncTime == null ? 'unknown' : reference.syncTime));
 
+    const seeked = mediaState.seeked;
+    mediaState.seeked = false;
     await this.playerInterface_.mediaSourceEngine.appendBuffer(
         mediaState.type,
         segment,
-        reference.startTime,
+        reference.syncTime == null ? reference.startTime : reference.syncTime,
         reference.endTime,
-        hasClosedCaptions);
+        hasClosedCaptions,
+        seeked);
     this.destroyer_.ensureNotDestroyed();
     shaka.log.v2(logPrefix, 'appended media segment');
   }
@@ -2017,6 +2031,7 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   waitingToFlushBuffer: boolean,
  *   clearBufferSafeMargin: number,
  *   clearingBuffer: boolean,
+ *   seeked: boolean,
  *   recovering: boolean,
  *   hasError: boolean,
  *   operation: shaka.net.NetworkingEngine.PendingRequest
@@ -2061,6 +2076,8 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   The amount of buffer to retain when clearing the buffer after the update.
  * @property {boolean} clearingBuffer
  *   True indicates that the buffer is being cleared.
+  * @property {boolean} seeked
+ *   True indicates that the presentation just seeked.
  * @property {boolean} recovering
  *   True indicates that the last segment was not appended because it could not
  *   fit in the buffer.

package/lib/media/time_ranges_utils.js

@@ -54,17 +54,13 @@ shaka.media.TimeRangesUtils = class {
 
 
   /**
-   * Determines if the given time is inside a buffered range.  This includes
-   * gaps, meaning that if the playhead is in a gap, it is considered buffered.
-   * If there is a small gap between the playhead and buffer start, consider it
-   * as buffered.
+   * Determines if the given time is inside a buffered range.
    *
    * @param {TimeRanges} b
    * @param {number} time Playhead time
-   * @param {number=} smallGapLimit Set in configuration
    * @return {boolean}
    */
-  static isBuffered(b, time, smallGapLimit = 0) {
+  static isBuffered(b, time) {
     if (!b || !b.length) {
       return false;
     }
@@ -76,9 +72,8 @@ shaka.media.TimeRangesUtils = class {
     if (time > b.end(b.length - 1)) {
       return false;
     }
-    // Push the time forward by the gap limit so that it is more likely to be in
-    // the range.
-    return (time + smallGapLimit >= b.start(0));
+
+    return time >= b.start(0);
   }
 
 

package/lib/net/networking_engine.js

@@ -220,6 +220,9 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
       retryParameters: retryParams,
       licenseRequestType: null,
       sessionId: null,
+      drmInfo: null,
+      initData: null,
+      initDataType: null,
       streamDataCallback: streamDataCallback,
     };
   }

package/lib/offline/indexeddb/v1_storage_cell.js

@@ -99,6 +99,7 @@ shaka.offline.indexeddb.V1StorageCell = class
       sessionIds: old.sessionIds,
       drmInfo: old.drmInfo,
       appMetadata: old.appMetadata,
+      sequenceMode: false,
     };
   }
 

package/lib/offline/indexeddb/v2_storage_cell.js

@@ -60,6 +60,7 @@ shaka.offline.indexeddb.V2StorageCell = class
       sessionIds: old.sessionIds,
       size: old.size,
       streams,
+      sequenceMode: false,
     };
   }
 

package/lib/offline/manifest_converter.js

@@ -87,6 +87,7 @@ shaka.offline.ManifestConverter = class {
       variants: Array.from(variants.values()),
       textStreams: textStreams,
       imageStreams: imageStreams,
+      sequenceMode: manifestDB.sequenceMode || false,
     };
   }
 

package/lib/offline/storage.js

@@ -7,7 +7,6 @@
 goog.provide('shaka.offline.Storage');
 
 goog.require('goog.asserts');
-goog.require('shaka.Deprecate');
 goog.require('shaka.Player');
 goog.require('shaka.log');
 goog.require('shaka.media.DrmEngine');
@@ -25,7 +24,6 @@ goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.ConfigUtils');
 goog.require('shaka.util.Destroyer');
 goog.require('shaka.util.Error');
-goog.require('shaka.util.Functional');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Iterables');
 goog.require('shaka.util.MimeUtils');
@@ -194,20 +192,8 @@ shaka.offline.Storage = class {
     if (arguments.length == 2 && typeof(config) == 'string') {
       config = shaka.util.ConfigUtils.convertToConfigObject(config, value);
     }
-
     goog.asserts.assert(typeof(config) == 'object', 'Should be an object!');
 
-    // Deprecate 'manifest.dash.defaultPresentationDelay' configuration.
-    if (config['manifest'] && config['manifest']['dash'] &&
-          'defaultPresentationDelay' in config['manifest']['dash']) {
-      shaka.Deprecate.deprecateFeature(4,
-          'manifest.dash.defaultPresentationDelay configuration',
-          'Please Use manifest.defaultPresentationDelay instead.');
-      config['manifest']['defaultPresentationDelay'] =
-          config['manifest']['dash']['defaultPresentationDelay'];
-      delete config['manifest']['dash']['defaultPresentationDelay'];
-    }
-
     goog.asserts.assert(
         this.config_, 'Cannot reconfigure storage after calling destroy.');
     return shaka.util.PlayerConfiguration.mergeConfigObjects(
@@ -291,7 +277,7 @@ shaka.offline.Storage = class {
           config.manifest.retryParameters,
           mimeType || null);
 
-      return shaka.util.Functional.callFactory(factory);
+      return factory();
     };
 
     /** @type {!shaka.offline.DownloadManager} */
@@ -308,33 +294,9 @@ shaka.offline.Storage = class {
       shaka.util.ArrayUtils.remove(this.openDownloadManagers_, downloader);
     });
 
-    // Provide a temporary shim for "then" for backward compatibility.
-    /** @type {!Object} */ (abortableStoreOp)['then'] = (onSuccess) => {
-      shaka.Deprecate.deprecateFeature(4,
-          'shaka.offline.Storage.store.then',
-          'Storage operations now return a shaka.util.AbortableOperation, ' +
-          'rather than a promise.  Please update to conform to this new API; ' +
-          'you can use the |chain| method instead.');
-      return abortableStoreOp.promise.then(onSuccess);
-    };
-
     return this.startAbortableOperation_(abortableStoreOp);
   }
 
-  /**
-   * Returns true if an asset is currently downloading.
-   *
-   * @return {boolean}
-   * @deprecated
-   * @export
-   */
-  getStoreInProgress() {
-    shaka.Deprecate.deprecateFeature(4,
-        'shaka.offline.Storage.getStoreInProgress',
-        'Multiple concurrent downloads are now supported.');
-    return false;
-  }
-
   /**
    * See |shaka.offline.Storage.store| for details.
    *
@@ -870,6 +832,7 @@ shaka.offline.Storage = class {
       drmInfo,
       appMetadata: metadata,
       isIncomplete: true,
+      sequenceMode: manifest.sequenceMode,
     };
 
     return {manifestDB, toDownload};
@@ -1365,6 +1328,9 @@ shaka.offline.Storage = class {
     const startTime =
         manifest.presentationTimeline.getSegmentAvailabilityStart();
 
+    const numberOfParallelDownloads = config.offline.numberOfParallelDownloads;
+    let groupId = 0;
+
     shaka.offline.Storage.forEachSegment_(stream, startTime, (segment) => {
       const pendingSegmentRefId =
           shaka.offline.DownloadInfo.idForSegmentRef(segment);
@@ -1378,7 +1344,7 @@ shaka.offline.Storage = class {
         const segmentDownload = new shaka.offline.DownloadInfo(
             segment,
             estimateId,
-            stream.id,
+            groupId,
             /* isInitSegment= */ false);
         toDownload.set(pendingSegmentRefId, segmentDownload);
       }
@@ -1393,7 +1359,7 @@ shaka.offline.Storage = class {
           const initDownload = new shaka.offline.DownloadInfo(
               segment.initSegmentReference,
               estimateId,
-              stream.id,
+              groupId,
               /* isInitSegment= */ true);
           toDownload.set(pendingInitSegmentRefId, initDownload);
         }
@@ -1413,6 +1379,7 @@ shaka.offline.Storage = class {
         dataKey: 0,
       };
       streamDb.segments.push(segmentDB);
+      groupId = (groupId + 1) % numberOfParallelDownloads;
     });
 
     return streamDb;