shaka-player 3.1.0 → 3.1.4

package/lib/hls/hls_parser.js

@@ -414,18 +414,16 @@ shaka.hls.HlsParser = class {
       const uri = tag.getAttributeValue('URI');
       const language = tag.getAttributeValue('LANGUAGE');
       const value = tag.getAttributeValue('VALUE');
-      const data = {
-        'id': id,
-      };
+      const data = (new Map()).set('id', id);
       if (uri) {
-        data.uri =
-            shaka.hls.Utils.constructAbsoluteUri(this.masterPlaylistUri_, uri);
+        data.set('uri',
+            shaka.hls.Utils.constructAbsoluteUri(this.masterPlaylistUri_, uri));
       }
       if (language) {
-        data.language = language;
+        data.set('language', language);
       }
       if (value) {
-        data.value = value;
+        data.set('value', value);
       }
       const event = new shaka.util.FakeEvent('sessiondata', data);
       if (this.playerInterface_) {
@@ -529,6 +527,30 @@ shaka.hls.HlsParser = class {
       }
     }
 
+    // Now that the content has been fit, notify segments.
+    this.segmentsToNotifyByStream_ = [];
+    const streamsToNotify = [];
+    for (const variant of variants) {
+      for (const stream of [variant.video, variant.audio]) {
+        if (stream) {
+          streamsToNotify.push(stream);
+        }
+      }
+    }
+    await Promise.all(streamsToNotify.map(async (stream) => {
+      await stream.createSegmentIndex();
+    }));
+    for (const stream of streamsToNotify) {
+      this.segmentsToNotifyByStream_.push(stream.segmentIndex.references);
+    }
+    this.notifySegments_();
+
+    // This asserts that the live edge is being calculated from segment times.
+    // For VOD and event streams, this check should still pass.
+    goog.asserts.assert(
+        !this.presentationTimeline_.usingPresentationStartTime(),
+        'We should not be using the presentation start time in HLS!');
+
     this.manifest_ = {
       presentationTimeline: this.presentationTimeline_,
       variants,
@@ -699,7 +721,8 @@ shaka.hls.HlsParser = class {
     // Create variants for each variant tag.
     const variantsPromises = tags.map(async (tag) => {
       const frameRate = tag.getAttributeValue('FRAME-RATE');
-      const bandwidth = Number(tag.getRequiredAttrValue('BANDWIDTH'));
+      const bandwidth = Number(tag.getAttributeValue('AVERAGE-BANDWIDTH')) ||
+        Number(tag.getRequiredAttrValue('BANDWIDTH'));
 
       const resolution = tag.getAttributeValue('RESOLUTION');
       const [width, height] = resolution ? resolution.split('x') : [null, null];
@@ -1150,7 +1173,7 @@ shaka.hls.HlsParser = class {
     // "AUTOSELECT=YES".  A value of "AUTOSELECT=NO" would imply that it may
     // only be selected explicitly by the user, and we don't have a way to
     // represent that in our model.
-    const defaultAttrValue = tag.getAttribute('DEFAULT');
+    const defaultAttrValue = tag.getAttributeValue('DEFAULT');
     const primary = defaultAttrValue == 'YES';
 
     const channelsCount = type == 'audio' ? this.getChannelsCount_(tag) : null;
@@ -1537,12 +1560,6 @@ shaka.hls.HlsParser = class {
     }
 
     this.notifySegments_();
-
-    // This asserts that the live edge is being calculated from segment times.
-    // For VOD and event streams, this check should still pass.
-    goog.asserts.assert(
-        !this.presentationTimeline_.usingPresentationStartTime(),
-        'We should not be using the presentation start time in HLS!');
   }
 
   /**
@@ -1914,9 +1931,6 @@ shaka.hls.HlsParser = class {
       }
     }
 
-    this.segmentsToNotifyByStream_.push(references);
-    this.notifySegments_();
-
     return references;
   }
 
@@ -2252,6 +2266,12 @@ shaka.hls.HlsParser = class {
       reader.rewind(1);
     };
 
+    // We will look a few packet-lengths forward to find the first sync byte.
+    // Note that we are using this method on what is already a subset of the
+    // file (the first |shaka.hls.HlsParser.START_OF_SEGMENT_SIZE_| bytes), so
+    // we can't look too far ahead to begin with.
+    let syncByteScanLength = Math.min(reader.getLength() - 188, 5 * 188);
+
     // TODO: refactor this while loop for better readability.
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -2260,8 +2280,16 @@ shaka.hls.HlsParser = class {
 
       syncByte = reader.readUint8();
       if (syncByte != 0x47) {
+        if (syncByteScanLength > 0) {
+          // This file could have started with a cut-off TS packet. Scan forward
+          // until we find a sync byte.
+          syncByteScanLength -= 1;
+          continue;
+        }
         fail();
       }
+      // If we've found a sync byte, stop scanning forward for future packets.
+      syncByteScanLength = 0;
 
       const flagsAndPacketId = reader.readUint16();
       const packetId = flagsAndPacketId & 0x1fff;

package/lib/media/closed_caption_parser.js

@@ -87,7 +87,9 @@ shaka.media.ClosedCaptionParser = class {
     for (const captionPacket of captionPackets) {
       const uint8ArrayData =
           shaka.util.BufferUtils.toUint8(captionPacket.packet);
-      this.ceaDecoder_.extract(uint8ArrayData, captionPacket.pts);
+      if (uint8ArrayData.length > 0) {
+        this.ceaDecoder_.extract(uint8ArrayData, captionPacket.pts);
+      }
     }
 
     // Decode and return the parsed captions.

package/lib/media/content_workarounds.js

@@ -75,6 +75,24 @@ shaka.media.ContentWorkarounds = class {
             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
           });
         })
+        .fullBox('avc3', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
+          });
+        })
+        .fullBox('ac-3', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCA_,
+          });
+        })
+        .fullBox('ec-3', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCA_,
+          });
+        })
         .fullBox('mp4a', (box) => {
           boxesToModify.push({
             box,

package/lib/media/drm_engine.js

@@ -126,6 +126,9 @@ shaka.media.DrmEngine = class {
 
     /** @const {!shaka.util.Destroyer} */
     this.destroyer_ = new shaka.util.Destroyer(() => this.destroyNow_());
+
+    /** @private {boolean} */
+    this.srcEquals_ = false;
   }
 
   /** @override */
@@ -181,6 +184,7 @@ shaka.media.DrmEngine = class {
     this.config_ = null;
     this.onError_ = () => {};
     this.playerInterface_ = null;
+    this.srcEquals_ = false;
   }
 
   /**
@@ -194,6 +198,13 @@ shaka.media.DrmEngine = class {
     this.config_ = config;
   }
 
+  /**
+   * @param {!boolean} value
+   */
+  setSrcEquals(value) {
+    this.srcEquals_ = value;
+  }
+
   /**
    * Initialize the drm engine for storing and deleting stored content.
    *
@@ -356,7 +367,7 @@ shaka.media.DrmEngine = class {
     // in the drm infos, and before queryMediaKeys_().
     if (useMediaCapabilities) {
       await shaka.util.StreamUtils.getDecodingInfosForVariants(variants,
-          this.usePersistentLicenses_);
+          this.usePersistentLicenses_, this.srcEquals_);
     } else {
       configsByKeySystem =
           this.prepareMediaKeyConfigsForVariants_(variants);
@@ -512,6 +523,7 @@ shaka.media.DrmEngine = class {
     tasks.push(session.remove());
 
     await Promise.all(tasks);
+    this.activeSessions_.delete(session);
   }
 
   /**
@@ -1877,9 +1889,16 @@ shaka.media.DrmEngine = class {
         // audio adaptations, so we shouldn't have to worry about checking
         // robustness.
         if (drm1.keySystem == drm2.keySystem) {
+          /** @type {Array<shaka.extern.InitDataOverride>} */
           let initData = [];
           initData = initData.concat(drm1.initData || []);
           initData = initData.concat(drm2.initData || []);
+          initData = initData.filter((d, i) => {
+            return d.keyId === undefined || i === initData.findIndex((d2) => {
+              return d2.keyId === d.keyId;
+            });
+          });
+
           const keyIds = drm1.keyIds && drm2.keyIds ?
               new Set([...drm1.keyIds, ...drm2.keyIds]) :
               drm1.keyIds || drm2.keyIds;

package/lib/media/gap_jumping_controller.js

@@ -154,8 +154,10 @@ shaka.media.GapJumpingController = class {
     }
     // Don't gap jump while paused, so that you don't constantly jump ahead
     // while paused on a livestream.  We make an exception for time 0, since we
-    // may be _required_ to seek on startup before play can begin.
-    if (this.video_.paused && this.video_.currentTime != 0) {
+    // may be _required_ to seek on startup before play can begin, but only if
+    // autoplay is enabled.
+    if (this.video_.paused && (this.video_.currentTime != 0 ||
+      (!this.video_.autoplay && this.video_.currentTime == 0))) {
       return;
     }
 
@@ -215,8 +217,10 @@ shaka.media.GapJumpingController = class {
       this.didFireLargeGap_ = true;
 
       // Event firing is synchronous.
-      const event = new shaka.util.FakeEvent(
-          'largegap', {'currentTime': currentTime, 'gapSize': jumpSize});
+      const data = new Map()
+          .set('currentTime', currentTime)
+          .set('gapSize', jumpSize);
+      const event = new shaka.util.FakeEvent('largegap', data);
       event.cancelable = true;
       this.onEvent_(event);
 

package/lib/media/media_source_engine.js

@@ -48,8 +48,7 @@ shaka.media.MediaSourceEngine = class {
    * @param {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)=}
    *    onMetadata
    */
-  constructor(video, closedCaptionParser, textDisplayer,
-      onMetadata) {
+  constructor(video, closedCaptionParser, textDisplayer, onMetadata) {
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 

package/lib/media/playhead.js

@@ -80,7 +80,7 @@ shaka.media.SrcEqualsPlayhead = class {
     // We listen for the loaded-data-event so that we know when we can
     // interact with |currentTime|.
     const onLoaded = () => {
-      if (this.startTime_ == null) {
+      if (this.startTime_ == null || this.startTime_ == 0) {
         this.started_ = true;
       } else {
         // Startup is complete only when the video element acknowledges the

package/lib/media/presentation_timeline.js

@@ -361,8 +361,10 @@ shaka.media.PresentationTimeline = class {
    */
   getSegmentAvailabilityEnd() {
     if (!this.isLive() && !this.isInProgress()) {
-      return this.duration_;
+      // It's a static manifest (can also be a dynamic->static conversion)
+      return this.maxSegmentEndTime_ || this.duration_;
     }
+    // Can be either live or "in-progress recording" (live with known duration)
     return Math.min(this.getLiveEdge_() + this.availabilityTimeOffset_,
         this.duration_);
   }

package/lib/media/segment_index.js

@@ -181,7 +181,9 @@ shaka.media.SegmentIndex = class {
 
   /**
    * Merges the given SegmentReferences.  Supports extending the original
-   * references only.  Will not replace old references or interleave new ones.
+   * references only.  Will replace old references with equivalent new ones, and
+   * keep any unique old ones.
+   *
    * Used, for example, by the DASH and HLS parser, where manifests may not list
    * all available references, so we must keep available references in memory to
    * fill the availability window.
@@ -189,6 +191,8 @@ 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) {
@@ -199,13 +203,13 @@ shaka.media.SegmentIndex = class {
       return;
     }
 
-    // Partial segments are used for live edge, and should be removed when they
-    // get older. Remove the old SegmentReferences after the first new
-    // reference's start time.
     if (!references.length) {
       return;
     }
 
+    // Partial segments are used for live edge, and should be removed when they
+    // get older. Remove the old SegmentReferences after the first new
+    // reference's start time.
     this.references = this.references.filter((r) => {
       return r.startTime < references[0].startTime;
     });
@@ -233,13 +237,27 @@ shaka.media.SegmentIndex = class {
    * @export
    */
   mergeAndEvict(references, windowStart) {
-    // FIlter out the references that are no longer available to avoid
+    // Filter out the references that are no longer available to avoid
     // repeatedly evicting them and messing up eviction count.
     references = references.filter((r) => {
-      return r.endTime > windowStart;
+      return r.endTime > windowStart &&
+          (this.references.length == 0 ||
+           r.endTime > this.references[0].startTime);
     });
 
+    const oldFirstRef = this.references[0];
     this.merge(references);
+    const newFirstRef = this.references[0];
+
+    if (oldFirstRef) {
+      // We don't compare the actual ref, since the object could legitimately be
+      // replaced with an equivalent.  Even the URIs could change due to
+      // load-balancing actions taken by the server.  However, if the time
+      // changes, its not an equivalent reference.
+      goog.asserts.assert(oldFirstRef.startTime == newFirstRef.startTime,
+          'SegmentIndex.merge should not change the first reference time!');
+    }
+
     this.evict(windowStart);
   }
 
@@ -363,22 +381,25 @@ shaka.media.SegmentIndex = class {
 
   /** @return {!shaka.media.SegmentIterator} */
   [Symbol.iterator]() {
-    return this.getIteratorForTime(0);
+    const iter = this.getIteratorForTime(0);
+    goog.asserts.assert(iter != null, 'Iterator for 0 should never be null!');
+    return iter;
   }
 
   /**
    * Returns a new iterator that initially points to the segment that contains
    * the given time.  Like the normal iterator, next() must be called first to
-   * get to the first element.
+   * get to the first element. Returns null if we do not find a segment at the
+   * requested time.
    *
    * @param {number} time
-   * @return {!shaka.media.SegmentIterator}
+   * @return {?shaka.media.SegmentIterator}
    * @export
    */
   getIteratorForTime(time) {
     let index = this.find(time);
     if (index == null) {
-      index = -1;
+      return null;
     } else {
       index--;
     }
@@ -497,8 +518,13 @@ shaka.media.SegmentIterator = class {
         'Please use SegmentIndex.getIteratorForTime instead of seek().');
 
     const iter = this.segmentIndex_.getIteratorForTime(time);
-    this.currentPosition_ = iter.currentPosition_;
-    this.currentPartialPosition_ = iter.currentPartialPosition_;
+    if (iter) {
+      this.currentPosition_ = iter.currentPosition_;
+      this.currentPartialPosition_ = iter.currentPartialPosition_;
+    } else {
+      this.currentPosition_ = Number.MAX_VALUE;
+      this.currentPartialPosition_ = 0;
+    }
     return this.next().value;
   }
 

package/lib/media/segment_reference.js

@@ -153,6 +153,14 @@ shaka.media.SegmentReference = class {
     /** @type {number} */
     this.endTime = endTime;
 
+    /**
+     * The "true" end time of the segment, without considering the period end
+     * time.  This is necessary for thumbnail segments, where timing requires us
+     * to know the original segment duration as described in the manifest.
+     * @type {number}
+     */
+    this.trueEndTime = endTime;
+
     /** @type {function():!Array.<string>} */
     this.getUrisInner = uris;
 

package/lib/media/streaming_engine.js

@@ -317,8 +317,10 @@ shaka.media.StreamingEngine = class {
    * @param {shaka.extern.Variant} variant
    * @param {boolean=} clearBuffer
    * @param {number=} safeMargin
+   * @param {boolean=} force
+   *   If true, reload the variant even if it did not change.
    */
-  switchVariant(variant, clearBuffer = false, safeMargin = 0) {
+  switchVariant(variant, clearBuffer = false, safeMargin = 0, force = false) {
     this.currentVariant_ = variant;
 
     if (!this.startupComplete_) {
@@ -329,12 +331,12 @@ shaka.media.StreamingEngine = class {
     if (variant.video) {
       this.switchInternal_(
           variant.video, /* clearBuffer= */ clearBuffer,
-          /* safeMargin= */ safeMargin, /* force= */ false);
+          /* safeMargin= */ safeMargin, /* force= */ force);
     }
     if (variant.audio) {
       this.switchInternal_(
           variant.audio, /* clearBuffer= */ clearBuffer,
-          /* safeMargin= */ safeMargin, /* force= */ false);
+          /* safeMargin= */ safeMargin, /* force= */ force);
     }
   }
 
@@ -1113,7 +1115,8 @@ shaka.media.StreamingEngine = class {
 
       mediaState.segmentIterator =
           mediaState.stream.segmentIndex.getIteratorForTime(time);
-      const ref = mediaState.segmentIterator.next().value;
+      const ref = mediaState.segmentIterator &&
+          mediaState.segmentIterator.next().value;
       if (ref == null) {
         shaka.log.warning(logPrefix, 'cannot find segment', 'endTime:', time);
       }
@@ -1135,14 +1138,16 @@ shaka.media.StreamingEngine = class {
       if (inaccurateTolerance) {
         mediaState.segmentIterator =
             mediaState.stream.segmentIndex.getIteratorForTime(lookupTime);
-        ref = mediaState.segmentIterator.next().value;
+        ref = mediaState.segmentIterator &&
+            mediaState.segmentIterator.next().value;
       }
       if (!ref) {
         // If we can't find a valid segment with the drifted time, look for a
         // segment with the presentation time.
         mediaState.segmentIterator =
             mediaState.stream.segmentIndex.getIteratorForTime(presentationTime);
-        ref = mediaState.segmentIterator.next().value;
+        ref = mediaState.segmentIterator &&
+            mediaState.segmentIterator.next().value;
       }
       if (ref == null) {
         shaka.log.warning(logPrefix, 'cannot find segment',
@@ -1185,10 +1190,14 @@ shaka.media.StreamingEngine = class {
 
     mediaState.performingUpdate = true;
 
-    const initSourceBuffer = this.initSourceBuffer_(mediaState, reference);
-
-    shaka.log.v2(logPrefix, 'fetching segment');
     try {
+      await this.initSourceBuffer_(mediaState, reference);
+      this.destroyer_.ensureNotDestroyed();
+      if (this.fatalError_) {
+        return;
+      }
+
+      shaka.log.v2(logPrefix, 'fetching segment');
       const isMP4 = stream.mimeType == 'video/mp4' ||
               stream.mimeType == 'audio/mp4';
       const isReadableStreamSupported = window.ReadableStream;
@@ -1196,7 +1205,6 @@ shaka.media.StreamingEngine = class {
       if (this.config_.lowLatencyMode && isReadableStreamSupported && isMP4) {
         let remaining = new Uint8Array(0);
         const streamDataCallback = async (data) => {
-          await initSourceBuffer;
           this.destroyer_.ensureNotDestroyed();
           if (this.fatalError_) {
             return;
@@ -1234,7 +1242,7 @@ shaka.media.StreamingEngine = class {
             'ReadableStream is not supported by the browser.');
         }
         const fetchSegment = this.fetch_(mediaState, reference);
-        const results = await Promise.all([initSourceBuffer, fetchSegment]);
+        const result = await fetchSegment;
         this.destroyer_.ensureNotDestroyed();
         if (this.fatalError_) {
           return;
@@ -1251,7 +1259,7 @@ shaka.media.StreamingEngine = class {
           return;
         }
         await this.append_(
-            mediaState, presentationTime, stream, reference, results[1]);
+            mediaState, presentationTime, stream, reference, result);
       }
 
       this.destroyer_.ensureNotDestroyed();
@@ -1289,7 +1297,13 @@ shaka.media.StreamingEngine = class {
 
       mediaState.performingUpdate = false;
 
-      if (mediaState.type == ContentType.TEXT &&
+      if (error.code == shaka.util.Error.Code.OPERATION_ABORTED) {
+        // 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.scheduleUpdate_(mediaState, 0);
+      } else if (mediaState.type == ContentType.TEXT &&
           this.config_.ignoreTextStreamFailures) {
         if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS) {
           shaka.log.warning(logPrefix,
@@ -1299,12 +1313,6 @@ shaka.media.StreamingEngine = class {
               'Text stream failed to parse. Proceeding without it.');
         }
         this.mediaStates_.delete(ContentType.TEXT);
-      } else if (error.code == shaka.util.Error.Code.OPERATION_ABORTED) {
-        // 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.scheduleUpdate_(mediaState, 0);
       } else if (error.code == shaka.util.Error.Code.QUOTA_EXCEEDED_ERROR) {
         this.handleQuotaExceeded_(mediaState, error);
       } else if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS &&
@@ -1654,7 +1662,8 @@ shaka.media.StreamingEngine = class {
 
         // Dispatch an event to notify the application about the emsg box.
         const eventName = shaka.Player.EventName.Emsg;
-        const event = new shaka.util.FakeEvent(eventName, {'detail': emsg});
+        const data = (new Map()).set('detail', emsg);
+        const event = new shaka.util.FakeEvent(eventName, data);
         this.playerInterface_.onEvent(event);
       }
     }
@@ -1738,7 +1747,7 @@ shaka.media.StreamingEngine = class {
    * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
    * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
    *   reference
-   * @param {?function(BufferSource)=} streamDataCallback
+   * @param {?function(BufferSource):!Promise=} streamDataCallback
    *
    * @return {!Promise.<BufferSource>}
    * @private

package/lib/net/http_fetch_plugin.js

@@ -92,7 +92,7 @@ shaka.net.HttpFetchPlugin = class {
    * @param {!RequestInit} init
    * @param {shaka.net.HttpFetchPlugin.AbortStatus} abortStatus
    * @param {shaka.extern.ProgressUpdated} progressUpdated
-   * @param {?function(BufferSource)} streamDataCallback
+   * @param {?function(BufferSource):!Promise} streamDataCallback
    * @return {!Promise<!shaka.extern.Response>}
    * @private
    */
@@ -140,7 +140,7 @@ shaka.net.HttpFetchPlugin = class {
           if (!readObj.done) {
             loaded += readObj.value.byteLength;
             if (streamDataCallback) {
-              streamDataCallback(readObj.value);
+              await streamDataCallback(readObj.value);
             }
           }
 

package/lib/net/networking_engine.js

@@ -196,7 +196,7 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
    *
    * @param {!Array.<string>} uris
    * @param {shaka.extern.RetryParameters} retryParams
-   * @param {?function(BufferSource)=} streamDataCallback
+   * @param {?function(BufferSource):!Promise=} streamDataCallback
    * @return {shaka.extern.Request}
    * @export
    */
@@ -544,7 +544,8 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
         }
 
         if (error.severity == shaka.util.Error.Severity.RECOVERABLE) {
-          const event = new shaka.util.FakeEvent('retry', {'error': error});
+          const data = (new Map()).set('error', error);
+          const event = new shaka.util.FakeEvent('retry', data);
           this.dispatchEvent(event);
 
           // Move to the next URI.

package/lib/offline/storage.js

@@ -539,6 +539,10 @@ shaka.offline.Storage = class {
             shaka.util.Error.Code.STORAGE_LIMIT_REACHED);
       }
     } catch (e) {
+      // It is necessary to be able to catch the STORAGE_LIMIT_REACHED error
+      if (e instanceof shaka.util.Error) {
+        throw e;
+      }
       shaka.log.warning(
           'downloadSizeCallback has produced an unexpected error', e);
       throw new shaka.util.Error(