shaka-player 4.3.1 → 4.3.2

package/lib/ads/ad_manager.js

@@ -19,8 +19,8 @@ goog.require('shaka.util.IReleasable');
 
 
 /**
- * @event shaka.ads.AdManager.ADS_LOADED
- * @description Fired when an ad has started playing.
+ * @event shaka.ads.AdManager.AdsLoadedEvent
+ * @description Fired when a sequence of ads has been loaded.
  * @property {string} type
  *   'ads-loaded'
  * @property {number} loadTime

package/lib/hls/hls_parser.js

@@ -2592,12 +2592,12 @@ shaka.hls.HlsParser = class {
     /** @type {shaka.extern.HlsAes128Key|undefined} */
     let hlsAes128Key = undefined;
 
-    // We may need to look at the media itself to determine a segment start
-    // time.
+    let discontinuitySequence = shaka.hls.Utils.getFirstTagWithNameAsNumber(
+        playlist.tags, 'EXT-X-DISCONTINUITY-SEQUENCE', 0);
     const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
         playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
-    const skipTag = shaka.hls.Utils.getFirstTagWithName(playlist.tags,
-        'EXT-X-SKIP');
+    const skipTag = shaka.hls.Utils.getFirstTagWithName(
+        playlist.tags, 'EXT-X-SKIP');
     const skippedSegments =
         skipTag ? Number(skipTag.getAttributeValue('SKIPPED-SEGMENTS')) : 0;
     let position = mediaSequenceNumber + skippedSegments;
@@ -2620,6 +2620,12 @@ shaka.hls.HlsParser = class {
           (i == 0) ? firstStartTime : previousReference.endTime;
       position = mediaSequenceNumber + skippedSegments + i;
 
+      const discontinuityTag = shaka.hls.Utils.getFirstTagWithName(
+          playlist.tags, 'EXT-X-DISCONTINUITY');
+      if (discontinuityTag) {
+        discontinuitySequence++;
+      }
+
       // Apply new AES-128 tags as you see them, keeping a running total.
       for (const drmTag of item.tags) {
         if (drmTag.name == 'EXT-X-KEY' &&
@@ -2657,6 +2663,8 @@ shaka.hls.HlsParser = class {
       previousReference = reference;
 
       if (reference) {
+        reference.discontinuitySequence = discontinuitySequence;
+
         if (this.config_.hls.ignoreManifestProgramDateTime &&
             this.minSequenceNumber_ != null &&
             position < this.minSequenceNumber_) {

package/lib/media/media_source_engine.js

@@ -924,6 +924,22 @@ shaka.media.MediaSourceEngine = class {
     ]);
   }
 
+  /**
+   * Adjust timestamp offset to maintain AV sync across discontinuities.
+   * Only used in sequence mode.
+   *
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {number} timestampOffset
+   * @return {!Promise}
+   */
+  async resync(contentType, timestampOffset) {
+    goog.asserts.assert(this.sequenceMode_,
+        'resyncAudio only used with sequence mode!');
+    await this.enqueueOperation_(
+        contentType,
+        () => this.setTimestampOffset_(contentType, timestampOffset));
+  }
+
   /**
    * @param {string=} reason Valid reasons are 'network' and 'decode'.
    * @return {!Promise}

package/lib/media/segment_reference.js

@@ -246,6 +246,9 @@ shaka.media.SegmentReference = class {
 
     /** @type {?shaka.media.SegmentReference.ThumbnailSprite} */
     this.thumbnailSprite = null;
+
+    /** @type {number} */
+    this.discontinuitySequence = 0;
   }
 
   /**

package/lib/media/streaming_engine.js

@@ -622,6 +622,11 @@ shaka.media.StreamingEngine = class {
    * within the presentation timeline.
    */
   seeked() {
+    if (!this.playerInterface_) {
+      // Already destroyed.
+      return;
+    }
+
     const presentationTime = this.playerInterface_.getPresentationTime();
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const newTimeIsBuffered = (type) => {
@@ -679,7 +684,7 @@ shaka.media.StreamingEngine = class {
 
   /**
    * Clear the buffer for a given stream.  Unlike clearBuffer_, this will handle
-   * cases where a MediaState is performing an update.  After this runs, every
+   * cases where a MediaState is performing an update.  After this runs, the
    * MediaState will have a pending update.
    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
    * @private
@@ -795,9 +800,9 @@ shaka.media.StreamingEngine = class {
     for (const type of streamsByType.keys()) {
       const stream = streamsByType.get(type);
       if (!this.mediaStates_.has(type)) {
-        const state = this.createMediaState_(stream);
-        this.mediaStates_.set(type, state);
-        this.scheduleUpdate_(state, 0);
+        const mediaState = this.createMediaState_(stream);
+        this.mediaStates_.set(type, mediaState);
+        this.scheduleUpdate_(mediaState, 0);
       }
     }
   }
@@ -909,7 +914,7 @@ shaka.media.StreamingEngine = class {
               'mediastate.stream should not have segmentIndex yet.');
           thisStream.closeSegmentIndex();
         }
-        if (mediaState.updateTimer == null) {
+        if (!mediaState.performingUpdate && !mediaState.updateTimer) {
           this.scheduleUpdate_(mediaState, 0);
         }
         return;
@@ -1394,7 +1399,7 @@ shaka.media.StreamingEngine = class {
         // If the network slows down, abort the current fetch request and start
         // a new one, and ignore the error message.
         mediaState.performingUpdate = false;
-        mediaState.updateTimer = null;
+        this.cancelUpdate_(mediaState);
         this.scheduleUpdate_(mediaState, 0);
       } else if (mediaState.type == ContentType.TEXT &&
           this.config_.ignoreTextStreamFailures) {
@@ -1467,7 +1472,10 @@ shaka.media.StreamingEngine = class {
 
     for (const mediaState of this.mediaStates_.values()) {
       const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
-      if (mediaState.hasError) {
+      // Only schedule an update if it has an error, but it's not mid-update
+      // and there is not already an update scheduled.
+      if (mediaState.hasError && !mediaState.performingUpdate &&
+          !mediaState.updateTimer) {
         shaka.log.info(logPrefix, 'Retrying after failure...');
         mediaState.hasError = false;
         this.scheduleUpdate_(mediaState, delaySeconds);
@@ -1661,6 +1669,19 @@ shaka.media.StreamingEngine = class {
       }
     }
 
+    if (this.manifest_.sequenceMode) {
+      // 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.
+      const lastDiscontinuitySequence =
+          mediaState.lastSegmentReference ?
+              mediaState.lastSegmentReference.discontinuitySequence : null;
+      if (reference.discontinuitySequence != lastDiscontinuitySequence) {
+        operations.push(this.playerInterface_.mediaSourceEngine.resync(
+            mediaState.type, reference.startTime));
+      }
+    }
+
     await Promise.all(operations);
   }
 
@@ -1715,8 +1736,6 @@ shaka.media.StreamingEngine = class {
 
     await this.evict_(mediaState, presentationTime);
     this.destroyer_.ensureNotDestroyed();
-    shaka.log.v1(logPrefix, 'appending media segment at',
-        (reference.syncTime == null ? 'unknown' : reference.syncTime));
 
     // 'seeked' or 'adaptation' triggered logic applies only to this
     // appendBuffer() call.
@@ -2079,7 +2098,11 @@ shaka.media.StreamingEngine = class {
     shaka.log.debug(logPrefix, 'cleared buffer');
     mediaState.clearingBuffer = false;
     mediaState.endOfStream = false;
-    this.scheduleUpdate_(mediaState, 0);
+    // Since the clear operation was async, check to make sure we're not doing
+    // another update and we don't have one scheduled yet.
+    if (!mediaState.performingUpdate && !mediaState.updateTimer) {
+      this.scheduleUpdate_(mediaState, 0);
+    }
   }
 
 

package/lib/player.js

@@ -4330,6 +4330,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return [];
     }
     const chapters = [];
+    const uniqueChapters = new Set();
     for (const chaptersTrack of chaptersTracksWithLanguage) {
       if (chaptersTrack && chaptersTrack.cues) {
         for (const cue of chaptersTrack.cues) {
@@ -4344,7 +4345,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             startTime: cue.startTime,
             endTime: cue.endTime,
           };
-          chapters.push(chapter);
+          if (!uniqueChapters.has(id)) {
+            chapters.push(chapter);
+            uniqueChapters.add(id);
+          }
         }
       }
     }
@@ -6974,7 +6978,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.3.1-uncompiled';
+shaka.Player.version = 'v4.3.2-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.3.1",
+  "version": "4.3.2",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [

package/test/player_integration.js

@@ -970,7 +970,7 @@ describe('Player', () => {
       expect(getBufferedBehind()).toBe(20);  // Buffered to start still.
       video.currentTime = 50;
       await waitUntilBuffered(30);
-      expect(getBufferedBehind()).toBeLessThan(30);
+      expect(getBufferedBehind()).toBeLessThan(40);  // 30 + segment_size
 
       player.configure('streaming.bufferBehind', 10);
       // We only evict content when we append a segment, so increase the
@@ -997,7 +997,7 @@ describe('Player', () => {
     }
 
     async function waitUntilBuffered(amount) {
-      for (let i = 0; i < 25; i++) {
+      for (let i = 0; i < 50; i++) {
         // We buffer from an internal segment, so this shouldn't take long to
         // buffer.
         await Util.delay(0.1);  // eslint-disable-line no-await-in-loop
@@ -1005,7 +1005,14 @@ describe('Player', () => {
           return;
         }
       }
-      throw new Error('Timeout waiting to buffer');
+
+      const ranges =
+          shaka.media.TimeRangesUtils.getBufferedInfo(video.buffered);
+      const currentTime = video.currentTime;
+      const target = currentTime + amount;
+
+      throw new Error('Timeout waiting to buffer! ' +
+          JSON.stringify({ranges, currentTime, target}));
     }
   });  // describe('buffering')
 

package/test/test/boot.js

@@ -66,22 +66,40 @@ function failTestsOnNamespacedElementOrAttributeNames() {
 }
 
 /**
- * Listen for unhandled Promise rejections (which may occur after a test) and
- * convert them into test failures.
+ * Fail the current test on a given error, constructed with a given header and
+ * the full stack trace of the error.
+ *
+ * @param {string} messageHeader
+ * @param {!Error} error
  */
-function failTestsOnUnhandledRejections() {
+function failOnError(messageHeader, error) {
+  let message = `${messageHeader}: ${error}`;
+  // Shaka errors have the stack trace in their toString() already, so don't
+  // add it again.  For native errors, we need to see where it came from.
+  if (error && error.stack && !(error instanceof shaka.util.Error)) {
+    message += '\n' + error.stack;
+  }
+  fail(message);
+}
+
+/**
+ * Listen for unhandled errors and Promise rejections (which may occur after a
+ * test) and convert them into test failures.
+ */
+function failTestsOnUnhandledErrors() {
   // https://developer.mozilla.org/en-US/docs/Web/Events/unhandledrejection
   window.addEventListener('unhandledrejection', (event) => {
     /** @type {?} */
     const error = event.reason;
-    let message = 'Unhandled rejection in Promise: ' + error;
+    failOnError('Unhandled rejection in Promise', error);
+  });
 
-    // Shaka errors have the stack trace in their toString() already, so don't
-    // add it again.  For native errors, we need to see where it came from.
-    if (error && error.stack && !(error instanceof shaka.util.Error)) {
-      message += '\n' + error.stack;
-    }
-    fail(message);
+  // https://developer.mozilla.org/en-US/docs/Web/API/Window/error_event
+  // https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
+  window.addEventListener('error', (event) => {
+    /** @type {?} */
+    const error = event['error'];
+    failOnError('Unhandled error', error);
   });
 }
 
@@ -387,7 +405,7 @@ function configureJasmineEnvironment() {
 function setupTestEnvironment() {
   failTestsOnFailedAssertions();
   failTestsOnNamespacedElementOrAttributeNames();
-  failTestsOnUnhandledRejections();
+  failTestsOnUnhandledErrors();
   disableScrollbars();
   workAroundLegacyEdgePromiseIssues();
 

package/test/test/util/manifest_parser_util.js

@@ -73,7 +73,7 @@ shaka.test.ManifestParser = class {
     const appendWindowStart = /** @type {?} */(jasmine.any(Number));
     const appendWindowEnd = /** @type {?} */(jasmine.any(Number));
 
-    return new shaka.media.SegmentReference(
+    const ref = new shaka.media.SegmentReference(
         start, end, getUris, startByte, endByte,
         initSegmentReference,
         timestampOffset,
@@ -82,7 +82,8 @@ shaka.test.ManifestParser = class {
         partialReferences,
         tilesLayout,
         /* tileDuration= */ undefined,
-        syncTime,
-    );
+        syncTime);
+    ref.discontinuitySequence = /** @type {?} */(jasmine.any(Number));
+    return ref;
   }
 };

package/test/test/util/test_scheme.js

@@ -413,7 +413,7 @@ const sintelAudioSegment = {
   mdhdOffset: 0x1b6,
   segmentUri: '/base/test/test/assets/sintel-audio-segment.mp4',
   tfdtOffset: 0x3c,
-  segmentDuration: 10.005,
+  segmentDuration: 10,
   mimeType: 'audio/mp4',
   codecs: 'mp4a.40.2',
 };
@@ -439,7 +439,7 @@ const sintelEncryptedAudio = {
   mdhdOffset: 0x1b6,
   segmentUri: '/base/test/test/assets/encrypted-sintel-audio-segment.mp4',
   tfdtOffset: 0x3c,
-  segmentDuration: 10.005,
+  segmentDuration: 10,
   mimeType: 'audio/mp4',
   codecs: 'mp4a.40.2',
   initData:

package/ui/controls.js

@@ -599,7 +599,11 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
         if (this.config_.forceLandscapeOnFullscreen && screen.orientation) {
           // Locking to 'landscape' should let it be either
           // 'landscape-primary' or 'landscape-secondary' as appropriate.
-          await screen.orientation.lock('landscape');
+          // We ignore errors from this specific call, since it creates noise
+          // on desktop otherwise.
+          try {
+            await screen.orientation.lock('landscape');
+          } catch (error) {}
         }
       } else {
         const video = /** @type {HTMLVideoElement} */(this.localVideo_);