shaka-player 4.4.2 → 4.5.0

package/lib/media/streaming_engine.js

@@ -1409,15 +1409,11 @@ shaka.media.StreamingEngine = class {
             'ReadableStream is not supported by the browser.');
         }
         const fetchSegment = this.fetch_(mediaState, reference);
-        let result = await fetchSegment;
+        const result = await fetchSegment;
         this.destroyer_.ensureNotDestroyed();
         if (this.fatalError_) {
           return;
         }
-        if (reference.hlsAes128Key) {
-          goog.asserts.assert(iter, 'mediaState.segmentIterator should exist');
-          result = await this.aes128Decrypt_(result, reference, iter);
-        }
         this.destroyer_.ensureNotDestroyed();
 
         // If the text stream gets switched between fetch_() and append_(), the
@@ -1502,13 +1498,13 @@ shaka.media.StreamingEngine = class {
 
   /**
    * @param {!BufferSource} rawResult
-   * @param {!shaka.media.SegmentReference} reference
+   * @param {shaka.extern.aes128Key} aes128Key
    * @param {!shaka.media.SegmentIterator} iter
    * @return {!Promise.<!BufferSource>} finalResult
    * @private
    */
-  async aes128Decrypt_(rawResult, reference, iter) {
-    const key = reference.hlsAes128Key;
+  async aes128Decrypt_(rawResult, aes128Key, iter) {
+    const key = aes128Key;
     if (!key.cryptoKey) {
       goog.asserts.assert(key.fetchKey, 'If AES-128 cryptoKey was not ' +
           'preloaded, fetchKey function should be provided');
@@ -1688,22 +1684,21 @@ shaka.media.StreamingEngine = class {
       shaka.log.v1(logPrefix,
           'setting append window end to ' + appendWindowEnd);
 
-      if ((mediaState.lastCodecs && codecs != mediaState.lastCodecs) ||
-          (mediaState.lastMimeType && mimeType != mediaState.lastMimeType)) {
+      const isResetMediaSourceNecessary =
+          mediaState.lastCodecs && mediaState.lastMimeType &&
+          this.playerInterface_.mediaSourceEngine.isResetMediaSourceNecessary(
+              mediaState.type, mediaState.stream);
+      if (isResetMediaSourceNecessary) {
+        let otherState = null;
         if (mediaState.type === ContentType.VIDEO) {
-          /** @type {shaka.media.StreamingEngine.MediaState_} */
-          const audioState = this.mediaStates_.get(ContentType.AUDIO);
-          if (audioState) {
-            audioState.lastInitSegmentReference = null;
-            this.abortOperations_(audioState);
-          }
+          otherState = this.mediaStates_.get(ContentType.AUDIO);
         } else if (mediaState.type === ContentType.AUDIO) {
-          /** @type {shaka.media.StreamingEngine.MediaState_} */
-          const videoState = this.mediaStates_.get(ContentType.VIDEO);
-          if (videoState) {
-            videoState.lastInitSegmentReference = null;
-            this.abortOperations_(videoState);
-          }
+          otherState = this.mediaStates_.get(ContentType.VIDEO);
+        }
+        if (otherState) {
+          otherState.lastInitSegmentReference = null;
+          this.forceClearBuffer_(otherState);
+          this.abortOperations_(otherState).catch(() => {});
         }
       }
 
@@ -1733,6 +1728,19 @@ shaka.media.StreamingEngine = class {
               mediaState.type, timestampOffset, appendWindowStart,
               appendWindowEnd, ignoreTimestampOffset,
               mediaState.stream, streamsByType);
+          if (isResetMediaSourceNecessary) {
+            let otherState = null;
+            if (mediaState.type === ContentType.VIDEO) {
+              otherState = this.mediaStates_.get(ContentType.AUDIO);
+            } else if (mediaState.type === ContentType.AUDIO) {
+              otherState = this.mediaStates_.get(ContentType.VIDEO);
+            }
+            if (otherState) {
+              otherState.waitingToClearBuffer = false;
+              otherState.performingUpdate = false;
+              this.forceClearBuffer_(otherState);
+            }
+          }
         } catch (error) {
           mediaState.lastAppendWindowStart = null;
           mediaState.lastAppendWindowEnd = null;
@@ -1742,7 +1750,10 @@ shaka.media.StreamingEngine = class {
           throw error;
         }
       };
-      operations.push(setProperties());
+      // Dispatching init asynchronously causes the sourceBuffers in
+      // the MediaSourceEngine to become detached do to race conditions
+      // with mediaSource and sourceBuffers being created simultaneously.
+      await setProperties();
     }
 
     if (!shaka.media.InitSegmentReference.equal(
@@ -1818,10 +1829,10 @@ shaka.media.StreamingEngine = class {
       }
     }
 
-    const lastDiscontinuitySequence =
-        mediaState.lastSegmentReference ?
-            mediaState.lastSegmentReference.discontinuitySequence : null;
     if (this.manifest_.sequenceMode) {
+      const lastDiscontinuitySequence =
+          mediaState.lastSegmentReference ?
+              mediaState.lastSegmentReference.discontinuitySequence : null;
       // Across discontinuity bounds, we should resync timestamps for
       // sequence mode playbacks.  The next segment appended should
       // land at its theoretical timestamp from the segment index.
@@ -1831,18 +1842,6 @@ shaka.media.StreamingEngine = class {
         operations.push(this.playerInterface_.mediaSourceEngine.resync(
             mediaState.type, reference.startTime));
       }
-    } else if (this.manifest_.ignoreManifestTimestampsInSegmentsMode) {
-      // In segments mode, we need to resync to set the timestampOffset
-      // to the start of the current discontinuity sequence. This is
-      // because individual discontinuity sequences may have internal
-      // timestamps that overlap, so we adjust the timestampOffset to avoid
-      // having the SourceBuffer get overwritten.
-      if (reference.discontinuitySequence != lastDiscontinuitySequence) {
-        operations.push(
-            this.playerInterface_.mediaSourceEngine.resync(
-                mediaState.type,
-                reference.timestampOffset));
-      }
     }
 
     await Promise.all(operations);
@@ -2200,7 +2199,13 @@ shaka.media.StreamingEngine = class {
     mediaState.operation = op;
     const response = await op.promise;
     mediaState.operation = null;
-    return response.data;
+    let result = response.data;
+    if (reference.aes128Key) {
+      const iter = mediaState.segmentIterator;
+      goog.asserts.assert(iter, 'mediaState.segmentIterator should exist');
+      result = await this.aes128Decrypt_(result, reference.aes128Key, iter);
+    }
+    return result;
   }
 
   /**

package/lib/mss/mss_parser.js

@@ -500,6 +500,7 @@ shaka.mss.MssParser = class {
     const stream = {
       id: id,
       originalId: streamIndex.getAttribute('Name') || String(id),
+      groupId: null,
       createSegmentIndex: () => Promise.resolve(),
       closeSegmentIndex: () => Promise.resolve(),
       segmentIndex: null,

package/lib/net/networking_engine.js

@@ -769,6 +769,7 @@ shaka.net.NetworkingEngine.RequestType = {
   'TIMING': 4,
   'SERVER_CERTIFICATE': 5,
   'KEY': 6,
+  'ADS': 7,
 };
 
 /**

package/lib/offline/indexeddb/v1_storage_cell.js

@@ -150,6 +150,7 @@ shaka.offline.indexeddb.V1StorageCell = class
     return {
       id: old.id,
       originalId: null,
+      groupId: null,
       primary: old.primary,
       type: old.contentType,
       mimeType: old.mimeType,

package/lib/offline/indexeddb/v2_storage_cell.js

@@ -99,6 +99,7 @@ shaka.offline.indexeddb.V2StorageCell = class
     return {
       id: old.id,
       originalId: old.originalId,
+      groupId: null,
       primary: old.primary,
       type: old.contentType,
       mimeType: old.mimeType,

package/lib/offline/manifest_converter.js

@@ -180,6 +180,7 @@ shaka.offline.ManifestConverter = class {
     const stream = {
       id: streamDB.id,
       originalId: streamDB.originalId,
+      groupId: streamDB.groupId,
       createSegmentIndex: () => Promise.resolve(),
       segmentIndex,
       mimeType: streamDB.mimeType,

package/lib/offline/storage.js

@@ -1168,6 +1168,8 @@ shaka.offline.Storage = class {
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
       newDrmInfo: (stream) => {},
+      onManifestUpdated: () => {},
+      getBandwidthEstimate: () => config.abr.defaultBandwidthEstimate,
     };
 
     parser.configure(config.manifest);
@@ -1299,6 +1301,7 @@ shaka.offline.Storage = class {
     const streamDb = {
       id: stream.id,
       originalId: stream.originalId,
+      groupId: stream.groupId,
       primary: stream.primary,
       type: stream.type,
       mimeType: stream.mimeType,