shaka-player 3.3.4 → 3.3.5

package/karma.conf.js

@@ -363,6 +363,8 @@ module.exports = (config) => {
     // If testing custom assets, we don't serve other unit or integration tests.
     // External asset tests are the basis for custom asset testing, so this file
     // is automatically included.
+    clientArgs.testFiles.push('demo/common/asset.js');
+    clientArgs.testFiles.push('demo/common/assets.js');
     clientArgs.testFiles.push('test/player_external.js');
   } else {
     // In a normal test run, we serve unit tests.
@@ -374,6 +376,8 @@ module.exports = (config) => {
     }
     if (settings.external) {
       // If --external is present, we serve external asset tests.
+      clientArgs.testFiles.push('demo/common/asset.js');
+      clientArgs.testFiles.push('demo/common/assets.js');
       clientArgs.testFiles.push('test/**/*_external.js');
     }
   }

package/lib/dash/dash_parser.js

@@ -764,8 +764,8 @@ shaka.dash.DashParser = class {
             // currently support that.  Just choose one.
             // TODO: https://github.com/shaka-project/shaka-player/issues/1528
             stream.trickModeVideo = trickModeSet.streams.find((trickStream) =>
-              shaka.util.MimeUtils.getCodecBase(stream.codecs) ==
-              shaka.util.MimeUtils.getCodecBase(trickStream.codecs));
+              shaka.util.MimeUtils.getNormalizedCodec(stream.codecs) ==
+              shaka.util.MimeUtils.getNormalizedCodec(trickStream.codecs));
           }
         }
       }
@@ -1228,7 +1228,6 @@ shaka.dash.DashParser = class {
     });
     let spatialAudio = false;
     if (hasJoc) {
-      context.representation.mimeType = 'audio/eac3-joc';
       spatialAudio = true;
     }
 

package/lib/hls/hls_parser.js

@@ -1739,8 +1739,8 @@ shaka.hls.HlsParser = class {
    * @param {number} timestampOffset
    * @param {!Map.<string, string>} variables
    * @param {string} absoluteMediaPlaylistUri
-   * @return {!shaka.media.SegmentReference}
    * @param {string} type
+   * @return {shaka.media.SegmentReference}
    * @private
    */
   createSegmentReference_(
@@ -1756,9 +1756,23 @@ shaka.hls.HlsParser = class {
     let startByte = 0;
     let endByte = null;
 
+    if (!extinfTag) {
+      if (hlsSegment.partialSegments.length == 0) {
+        // EXTINF tag must be available if the segment has no partial segments.
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MANIFEST,
+            shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, 'EXTINF');
+      } else if (!this.lowLatencyMode_) {
+        // Without EXTINF and without low-latency mode, partial segments get
+        // ignored.
+        return null;
+      }
+    }
+
     // Create SegmentReferences for the partial segments.
     const partialSegmentRefs = [];
-    if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
+    if (this.lowLatencyMode_) {
       for (let i = 0; i < hlsSegment.partialSegments.length; i++) {
         const item = hlsSegment.partialSegments[i];
         const pPreviousReference = i == 0 ?
@@ -1799,14 +1813,6 @@ shaka.hls.HlsParser = class {
             /* appendWindowEnd= */ Infinity);
         partialSegmentRefs.push(partial);
       } // for-loop of hlsSegment.partialSegments
-    } else {
-      // EXTINF tag must be available if the segment has no partial segments.
-      if (!extinfTag) {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.MANIFEST,
-            shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, 'EXTINF');
-      }
     }
 
     // If the segment has EXTINF tag, set the segment's end time, start byte
@@ -1825,6 +1831,7 @@ shaka.hls.HlsParser = class {
     } else {
       endTime = partialSegmentRefs[partialSegmentRefs.length - 1].endTime;
     }
+
     // If the segment has EXT-X-BYTERANGE tag, set the start byte and end byte
     // base on the byterange information. If segment has no EXT-X-BYTERANGE tag
     // and has partial segments, set the start byte and end byte base on the
@@ -2054,7 +2061,9 @@ shaka.hls.HlsParser = class {
             playlist.absoluteUri,
             type);
 
-        references.push(reference);
+        if (reference) {
+          references.push(reference);
+        }
       } else if (!this.lowLatencyMode_) {
         // If a segment has no extinfTag, it must contain partial segments.
         shaka.log.alwaysWarn('Low-latency HLS live stream detected, but ' +
@@ -2233,6 +2242,9 @@ shaka.hls.HlsParser = class {
         variables,
         /* absoluteMediaPlaylistUri= */ '',
         type);
+    goog.asserts.assert(
+        segmentRef != null, 'Segment reference should not be null!');
+
     // If we are updating the manifest, we can usually skip fetching the segment
     // by examining the references we already have.  This won't be possible if
     // there was some kind of lag or delay updating the manifest on the server,

package/lib/media/media_source_engine.js

@@ -63,6 +63,11 @@ shaka.media.MediaSourceEngine = class {
                            string>} */
     this.sourceBufferTypes_ = {};
 
+
+    /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
+                           boolean>} */
+    this.expectedEncryption_ = {};
+
     /** @private {shaka.text.TextEngine} */
     this.textEngine_ = null;
 
@@ -345,6 +350,7 @@ shaka.media.MediaSourceEngine = class {
         this.sourceBuffers_[contentType] = sourceBuffer;
         this.sourceBufferTypes_[contentType] = mimeType;
         this.queues_[contentType] = [];
+        this.expectedEncryption_[contentType] = !!stream.drmInfos.length;
       }
     }
   }
@@ -1091,7 +1097,7 @@ shaka.media.MediaSourceEngine = class {
    */
   workAroundBrokenPlatforms_(segment, startTime, contentType) {
     const isInitSegment = startTime == null;
-    const encryptionExpected = this.video_.mediaKeys;
+    const encryptionExpected = this.expectedEncryption_[contentType];
 
     // If:
     //   1. this is an init segment,

package/lib/offline/indexeddb/storage_mechanism.js

@@ -368,8 +368,10 @@ shaka.offline.indexeddb.StorageMechanism.SESSION_ID_STORE = 'session-ids';
 shaka.offline.StorageMuxer.register(
     'idb',
     () => {
-      // Offline storage is not supported on the Chromecast platform.
-      if (shaka.util.Platform.isChromecast()) {
+      // Offline storage is not supported on the Chromecast or Xbox One
+      // platforms.
+      if (shaka.util.Platform.isChromecast() ||
+          shaka.util.Platform.isXboxOne()) {
         return null;
       }
       // Offline storage requires the IndexedDB API.

package/lib/offline/storage.js

@@ -29,7 +29,6 @@ goog.require('shaka.util.Functional');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Iterables');
 goog.require('shaka.util.MimeUtils');
-goog.require('shaka.util.Mutex');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.PlayerConfiguration');
 goog.require('shaka.util.StreamUtils');
@@ -210,7 +209,7 @@ shaka.offline.Storage = class {
     }
 
     goog.asserts.assert(
-        this.config_, 'Cannot reconfigure stroage after calling destroy.');
+        this.config_, 'Cannot reconfigure storage after calling destroy.');
     return shaka.util.PlayerConfiguration.mergeConfigObjects(
         /* destination= */ this.config_, /* updates= */ config );
   }
@@ -479,36 +478,34 @@ shaka.offline.Storage = class {
   async downloadSegments_(
       toDownload, manifestId, manifestDB, downloader, config, storage,
       manifest, drmEngine) {
+    let pendingManifestUpdates = {};
+    let pendingDataSize = 0;
+
     /**
      * @param {!Array.<!shaka.offline.DownloadInfo>} toDownload
      * @param {boolean} updateDRM
      */
     const download = async (toDownload, updateDRM) => {
-      const throwIfAbortedFn = () => {
-        this.ensureNotDestroyed_();
-      };
       for (const download of toDownload) {
-        /** @param {?BufferSource} data */
-        let data;
         const request = download.makeSegmentRequest(config);
         const estimateId = download.estimateId;
         const isInitSegment = download.isInitSegment;
-        const onDownloaded = (d) => {
-          data = d;
-          return Promise.resolve();
-        };
-        downloader.queue(download.groupId,
-            request, estimateId, isInitSegment, onDownloaded);
-        downloader.queueWork(download.groupId, async () => {
-          goog.asserts.assert(data, 'We should have loaded data by now');
-          goog.asserts.assert(data instanceof ArrayBuffer,
-              'The data should be an ArrayBuffer');
 
+        const onDownloaded = async (data) => {
+          // Store the data.
+          const dataKeys = await storage.addSegments([{data}]);
+          this.ensureNotDestroyed_();
+
+          // Store the necessary update to the manifest, to be processed later.
           const ref = /** @type {!shaka.media.SegmentReference} */ (
             download.ref);
-          manifestDB = (await shaka.offline.Storage.assignStreamToManifest(
-              manifestId, ref, {data}, throwIfAbortedFn)) || manifestDB;
-        });
+          const id = shaka.offline.DownloadInfo.idForSegmentRef(ref);
+          pendingManifestUpdates[id] = dataKeys[0];
+          pendingDataSize += data.byteLength;
+        };
+
+        downloader.queue(download.groupId,
+            request, estimateId, isInitSegment, onDownloaded);
       }
       await downloader.waitToFinish();
 
@@ -516,8 +513,8 @@ shaka.offline.Storage = class {
         // Re-store the manifest, to attach session IDs.
         // These were (maybe) discovered inside the downloader; we can only add
         // them now, at the end, since the manifestDB is in flux during the
-        // process of downloading and storing, and assignStreamToManifest does
-        // not know about the DRM engine.
+        // process of downloading and storing, and assignSegmentsToManifest
+        // does not know about the DRM engine.
         this.ensureNotDestroyed_();
         this.setManifestDrmFields_(manifest, manifestDB, drmEngine, config);
         await storage.updateManifest(manifestId, manifestDB);
@@ -526,24 +523,54 @@ shaka.offline.Storage = class {
 
     const usingBgFetch = false; // TODO: Get.
 
-    if (this.getManifestIsEncrypted_(manifest) && usingBgFetch &&
-        !this.getManifestIncludesInitData_(manifest)) {
-      // Background fetch can't make DRM sessions, so if we have to get the
-      // init data from the init segments, download those first before anything
-      // else.
-      await download(toDownload.filter((info) => info.isInitSegment), true);
-      this.ensureNotDestroyed_();
-      toDownload = toDownload.filter((info) => !info.isInitSegment);
-    }
+    try {
+      if (this.getManifestIsEncrypted_(manifest) && usingBgFetch &&
+          !this.getManifestIncludesInitData_(manifest)) {
+        // Background fetch can't make DRM sessions, so if we have to get the
+        // init data from the init segments, download those first before
+        // anything else.
+        await download(toDownload.filter((info) => info.isInitSegment), true);
+        this.ensureNotDestroyed_();
+        toDownload = toDownload.filter((info) => !info.isInitSegment);
 
-    if (!usingBgFetch) {
-      await download(toDownload, false);
-      this.ensureNotDestroyed_();
+        // Copy these and reset them now, before calling await.
+        const manifestUpdates = pendingManifestUpdates;
+        const dataSize = pendingDataSize;
+        pendingManifestUpdates = {};
+        pendingDataSize = 0;
 
-      goog.asserts.assert(
-          !manifestDB.isIncomplete, 'The manifest should be complete by now');
-    } else {
-      // TODO: Send the request to the service worker. Don't await the result.
+        await shaka.offline.Storage.assignSegmentsToManifest(
+            storage, manifestId, manifestDB, manifestUpdates, dataSize,
+            () => this.ensureNotDestroyed_());
+        this.ensureNotDestroyed_();
+      }
+
+      if (!usingBgFetch) {
+        await download(toDownload, false);
+        this.ensureNotDestroyed_();
+
+        // Copy these and reset them now, before calling await.
+        const manifestUpdates = pendingManifestUpdates;
+        const dataSize = pendingDataSize;
+        pendingManifestUpdates = {};
+        pendingDataSize = 0;
+
+        await shaka.offline.Storage.assignSegmentsToManifest(
+            storage, manifestId, manifestDB, manifestUpdates, dataSize,
+            () => this.ensureNotDestroyed_());
+        this.ensureNotDestroyed_();
+
+        goog.asserts.assert(
+            !manifestDB.isIncomplete, 'The manifest should be complete by now');
+      } else {
+        // TODO: Send the request to the service worker. Don't await the result.
+      }
+    } catch (error) {
+      const dataKeys = Object.values(pendingManifestUpdates);
+      // Remove these pending segments that are not yet linked to the manifest.
+      await storage.removeSegments(dataKeys, (key) => {});
+
+      throw error;
     }
   }
 
@@ -567,70 +594,50 @@ shaka.offline.Storage = class {
   }
 
   /**
-   * Load the given manifest, modifies it by assigning the given data to the
-   * segments corresponding to "ref", then re-stores the manifest.
-   * The parts of this function that modify the manifest are protected by a
-   * mutex, to prevent race conditions; specifically, it prevents two parallel
-   * instances of this method from both loading the manifest into memory at the
-   * same time, which would result in the slower/later call overwriting the
-   * changes of the other.
+   * Updates the given manifest, assigns database keys to segments, then stores
+   * the updated manifest.
    *
+   * It is up to the caller to ensure that this method is not called
+   * concurrently on the same manifest.
+   *
+   * @param {shaka.extern.StorageCell} storage
    * @param {number} manifestId
-   * @param {!shaka.media.SegmentReference} ref
-   * @param {shaka.extern.SegmentDataDB} data
+   * @param {!shaka.extern.ManifestDB} manifestDB
+   * @param {!Object.<string, number>} manifestUpdates
+   * @param {number} dataSizeUpdate
    * @param {function()} throwIfAbortedFn  A function that should throw if the
    *   download has been aborted.
-   * @return {!Promise.<?shaka.extern.ManifestDB>}
+   * @return {!Promise}
    */
-  static async assignStreamToManifest(manifestId, ref, data, throwIfAbortedFn) {
-    /** @type {shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-
-    const idForRef = shaka.offline.DownloadInfo.idForSegmentRef(ref);
+  static async assignSegmentsToManifest(
+      storage, manifestId, manifestDB, manifestUpdates, dataSizeUpdate,
+      throwIfAbortedFn) {
     let manifestUpdated = false;
-    let dataKey;
-    let activeHandle;
-    /** @type {!shaka.extern.ManifestDB} */
-    let manifestDB;
-
-    let mutexId = 0;
 
     try {
-      await muxer.init();
-      activeHandle = await muxer.getActive();
-
-      // Store the data.
-      const dataKeys = await activeHandle.cell.addSegments([data]);
-      dataKey = dataKeys[0];
-      throwIfAbortedFn();
-
-      // Acquire the mutex before accessing the manifest, since there could be
-      // multiple instances of this method running at once.
-      mutexId = await shaka.offline.Storage.mutex_.acquire();
-      throwIfAbortedFn();
-
-      // Load the manifest.
-      const manifests = await activeHandle.cell.getManifests([manifestId]);
-      throwIfAbortedFn();
-      manifestDB = manifests[0];
-
       // Assign the stored data to the manifest.
       let complete = true;
       for (const stream of manifestDB.streams) {
         for (const segment of stream.segments) {
-          if (segment.pendingSegmentRefId == idForRef) {
+          let dataKey = segment.pendingSegmentRefId ?
+              manifestUpdates[segment.pendingSegmentRefId] : null;
+          if (dataKey != null) {
             segment.dataKey = dataKey;
             // Now that the segment has been associated with the appropriate
             // dataKey, the pendingSegmentRefId is no longer necessary.
             segment.pendingSegmentRefId = undefined;
           }
-          if (segment.pendingInitSegmentRefId == idForRef) {
+
+          dataKey = segment.pendingInitSegmentRefId ?
+              manifestUpdates[segment.pendingInitSegmentRefId] : null;
+          if (dataKey != null) {
             segment.initSegmentKey = dataKey;
             // Now that the init segment has been associated with the
             // appropriate initSegmentKey, the pendingInitSegmentRefId is no
             // longer necessary.
             segment.pendingInitSegmentRefId = undefined;
           }
+
           if (segment.pendingSegmentRefId) {
             complete = false;
           }
@@ -641,33 +648,30 @@ shaka.offline.Storage = class {
       }
 
       // Update the size of the manifest.
-      manifestDB.size += data.data.byteLength;
+      manifestDB.size += dataSizeUpdate;
 
       // Mark the manifest as complete, if all segments are downloaded.
       if (complete) {
         manifestDB.isIncomplete = false;
       }
 
-      // Re-store the manifest.
-      await activeHandle.cell.updateManifest(manifestId, manifestDB);
+      // Update the manifest.
+      await storage.updateManifest(manifestId, manifestDB);
       manifestUpdated = true;
       throwIfAbortedFn();
     } catch (e) {
       await shaka.offline.Storage.cleanStoredManifest(manifestId);
 
-      if (activeHandle && !manifestUpdated && dataKey) {
+      if (!manifestUpdated) {
+        const dataKeys = Object.values(manifestUpdates);
         // The cleanStoredManifest method will not "see" any segments that have
         // been downloaded but not assigned to the manifest yet. So un-store
         // them separately.
-        await activeHandle.cell.removeSegments([dataKey], (key) => {});
+        await storage.removeSegments(dataKeys, (key) => {});
       }
 
       throw e;
-    } finally {
-      await muxer.destroy();
-      shaka.offline.Storage.mutex_.release(mutexId);
     }
-    return manifestDB;
   }
 
   /**
@@ -1662,9 +1666,6 @@ shaka.offline.Storage = class {
   }
 };
 
-/** @private {!shaka.util.Mutex} */
-shaka.offline.Storage.mutex_ = new shaka.util.Mutex();
-
 shaka.offline.Storage.defaultSystemIds_ = new Map()
     .set('org.w3.clearkey', '1077efecc0b24d02ace33c1e52e2fb4b')
     .set('com.widevine.alpha', 'edef8ba979d64acea3c827dcd51d21ed')