shaka-player 4.3.2 → 4.3.3

package/lib/hls/hls_parser.js

@@ -493,7 +493,11 @@ shaka.hls.HlsParser = class {
         // Now adjust timestamps back to begin at 0.
         const segmentN = segmentIndex.earliestReference();
         if (segmentN) {
-          this.offsetStream_(streamInfo, -segmentN.startTime);
+          const streamOffset = -segmentN.startTime;
+          // Modify all SegmentReferences equally.
+          streamInfo.stream.segmentIndex.offset(streamOffset);
+          // Update other parts of streamInfo the same way.
+          this.offsetStreamInfo_(streamInfo, streamOffset);
         }
       }
     }
@@ -535,22 +539,29 @@ shaka.hls.HlsParser = class {
     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
       const segmentIndex = streamInfo.stream.segmentIndex;
       if (segmentIndex != null) {
+        // A segment's startTime should be based on its syncTime vs the lowest
+        // syncTime across all streams.  The earliest segment sync time from
+        // any stream will become presentation time 0.  If two streams start
+        // e.g. 6 seconds apart in syncTime, then their first segments will
+        // also start 6 seconds apart in presentation time.
+
         const segment0 = segmentIndex.earliestReference();
         if (segment0.syncTime == null) {
           shaka.log.alwaysError('Missing EXT-X-PROGRAM-DATE-TIME for stream',
               streamInfo.verbatimMediaPlaylistUri,
               'Expect AV sync issues!');
         } else {
-          // The first segment's target startTime should be based entirely on
-          // its syncTime.  The rest of the stream will be based on that
-          // starting point.  The earliest segment sync time from any stream
-          // will become presentation time 0.  If two streams start e.g. 6
-          // seconds apart in syncTime, then their first segments will also
-          // start 6 seconds apart in presentation time.
+          // Stream metadata are offset by a fixed amount based on the
+          // first segment.
           const segment0TargetTime = segment0.syncTime - lowestSyncTime;
           const streamOffset = segment0TargetTime - segment0.startTime;
+          this.offsetStreamInfo_(streamInfo, streamOffset);
 
-          this.offsetStream_(streamInfo, streamOffset);
+          // This is computed across all segments separately to manage
+          // accumulated drift in durations.
+          for (const segment of segmentIndex) {
+            segment.syncAgainst(lowestSyncTime);
+          }
         }
       }
     }
@@ -561,13 +572,13 @@ shaka.hls.HlsParser = class {
    * @param {number} offset
    * @private
    */
-  offsetStream_(streamInfo, offset) {
-    streamInfo.stream.segmentIndex.offset(offset);
-
+  offsetStreamInfo_(streamInfo, offset) {
+    // Adjust our accounting of the maximum timestamp.
     streamInfo.maxTimestamp += offset;
     goog.asserts.assert(streamInfo.maxTimestamp >= 0,
         'Negative maxTimestamp after adjustment!');
 
+    // Update our map from sequence number to start time.
     const mediaSequenceToStartTime =
         this.getMediaSequenceToStartTimeFor_(streamInfo);
     for (const [key, value] of mediaSequenceToStartTime) {
@@ -2621,16 +2632,19 @@ shaka.hls.HlsParser = class {
       position = mediaSequenceNumber + skippedSegments + i;
 
       const discontinuityTag = shaka.hls.Utils.getFirstTagWithName(
-          playlist.tags, 'EXT-X-DISCONTINUITY');
+          item.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' &&
-            drmTag.getRequiredAttrValue('METHOD') == 'AES-128') {
-          hlsAes128Key = this.parseAES128DrmTag_(drmTag, playlist);
+        if (drmTag.name == 'EXT-X-KEY') {
+          if (drmTag.getRequiredAttrValue('METHOD') == 'AES-128') {
+            hlsAes128Key = this.parseAES128DrmTag_(drmTag, playlist);
+          } else {
+            hlsAes128Key = undefined;
+          }
         }
       }
 
@@ -2751,6 +2765,16 @@ shaka.hls.HlsParser = class {
       }
     }
 
+    // lowestSyncTime is a value from a previous playlist update.  Use it to
+    // set reference start times.  If this is the first playlist parse, we will
+    // skip this step, and wait until we have sync time across stream types.
+    const lowestSyncTime = this.lowestSyncTime_;
+    if (someSyncTime && lowestSyncTime != Infinity) {
+      for (const reference of references) {
+        reference.syncAgainst(lowestSyncTime);
+      }
+    }
+
     return references;
   }
 

package/lib/media/media_source_engine.js

@@ -682,6 +682,8 @@ shaka.media.MediaSourceEngine = class {
       // into extracting a timestamp for us to align text segments in sequence
       // mode.
 
+      const duration = this.mediaSource_.duration;
+
       // Timestamps can only be reliably extracted from video, not audio.
       // Packed audio formats do not have internal timestamps at all.
       // Prefer video for this when available.
@@ -725,7 +727,7 @@ shaka.media.MediaSourceEngine = class {
         // Clear the buffer.
         await this.enqueueOperation_(
             contentType,
-            () => this.remove_(contentType, 0, this.mediaSource_.duration));
+            () => this.remove_(contentType, 0, duration));
 
         // Finally, flush the buffer in case of choppy video start on HLS fMP4.
         if (contentType == ContentType.VIDEO) {
@@ -737,6 +739,10 @@ shaka.media.MediaSourceEngine = class {
 
       // Now switch to sequence mode and fall through to our normal operations.
       sourceBuffer.mode = SEQUENCE;
+
+      // When we change the buffer mode the duration is lost, so we need to set
+      // it explicitly.
+      await this.setDuration(duration);
     }
 
     if (reference && this.sequenceMode_ && contentType != ContentType.TEXT) {
@@ -771,8 +777,13 @@ shaka.media.MediaSourceEngine = class {
           bufferedBefore, bufferedAfter);
       if (newBuffered) {
         const segmentDuration = reference.endTime - reference.startTime;
-        if (Math.abs(newBuffered.start - reference.startTime) >
-            segmentDuration / 2) {
+        // Check end times instead of start times.  We may be overwriting a
+        // buffer and only the end changes, and that would be fine.
+        // Also, exclude tiny segments.  Sometimes alignment segments as small
+        // as 33ms are seen in Google DAI content.  For such tiny segments,
+        // half a segment duration would be no issue.
+        const offset = Math.abs(newBuffered.end - reference.endTime);
+        if (segmentDuration > 0.100 && offset > segmentDuration / 2) {
           shaka.log.error('Possible encoding problem detected!',
               'Unexpected buffered range for reference', reference,
               'from URIs', reference.getUris(),
@@ -933,8 +944,27 @@ shaka.media.MediaSourceEngine = class {
    * @return {!Promise}
    */
   async resync(contentType, timestampOffset) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+
     goog.asserts.assert(this.sequenceMode_,
-        'resyncAudio only used with sequence mode!');
+        'resync only used with sequence mode!');
+
+    if (contentType == ContentType.TEXT) {
+      // This operation is for audio and video only.
+      return;
+    }
+
+    // Queue an abort() to help MSE splice together overlapping segments.
+    // We set appendWindowEnd when we change periods in DASH content, and the
+    // period transition may result in overlap.
+    //
+    // An abort() also helps with MPEG2-TS.  When we append a TS segment, we
+    // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
+    // timestamp offset.  By calling abort(), we reset the state so we can
+    // set it.
+    this.enqueueOperation_(
+        contentType,
+        () => this.abort_(contentType));
     await this.enqueueOperation_(
         contentType,
         () => this.setTimestampOffset_(contentType, timestampOffset));

package/lib/media/segment_index.js

@@ -183,15 +183,7 @@ shaka.media.SegmentIndex = class {
   offset(offset) {
     if (!this.immutable_) {
       for (const ref of this.references) {
-        ref.startTime += offset;
-        ref.endTime += offset;
-        ref.trueEndTime += offset;
-
-        for (const partial of ref.partialReferences) {
-          partial.startTime += offset;
-          partial.endTime += offset;
-          partial.trueEndTime += offset;
-        }
+        ref.offset(offset);
       }
     }
   }
@@ -225,8 +217,11 @@ shaka.media.SegmentIndex = class {
     // 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.
+    // Use times rounded to the millisecond for filtering purposes, so that
+    // tiny rounding errors will not result in duplicate segments in the index.
+    const firstStartTime = Math.round(references[0].startTime * 1000) / 1000;
     this.references = this.references.filter((r) => {
-      return r.startTime < references[0].startTime;
+      return (Math.round(r.startTime * 1000) / 1000) < firstStartTime;
     });
 
     this.references.push(...references);

package/lib/media/segment_reference.js

@@ -8,6 +8,7 @@ goog.provide('shaka.media.InitSegmentReference');
 goog.provide('shaka.media.SegmentReference');
 
 goog.require('goog.asserts');
+goog.require('shaka.log');
 goog.require('shaka.util.ArrayUtils');
 
 
@@ -383,6 +384,44 @@ shaka.media.SegmentReference = class {
   getThumbnailSprite() {
     return this.thumbnailSprite;
   }
+
+  /**
+   * Offset the segment reference by a fixed amount.
+   *
+   * @param {number} offset The amount to add to the segment's start and end
+   *   times.
+   * @export
+   */
+  offset(offset) {
+    this.startTime += offset;
+    this.endTime += offset;
+    this.trueEndTime += offset;
+
+    for (const partial of this.partialReferences) {
+      partial.startTime += offset;
+      partial.endTime += offset;
+      partial.trueEndTime += offset;
+    }
+  }
+
+  /**
+   * Sync this segment against a particular sync time that will serve as "0" in
+   * the presentation timeline.
+   *
+   * @param {number} lowestSyncTime
+   * @export
+   */
+  syncAgainst(lowestSyncTime) {
+    if (this.syncTime == null) {
+      shaka.log.alwaysError('Sync attempted without sync time!');
+      return;
+    }
+    const desiredStart = this.syncTime - lowestSyncTime;
+    const offset = desiredStart - this.startTime;
+    if (Math.abs(offset) >= 0.001) {
+      this.offset(offset);
+    }
+  }
 };
 
 

package/lib/media/streaming_engine.js

@@ -836,6 +836,7 @@ shaka.media.StreamingEngine = class {
       // The playhead might be seeking on startup, if a start time is set, so
       // start "seeked" as true.
       seeked: true,
+      needsResync: false,
       recovering: false,
       hasError: false,
       operation: null,
@@ -1159,6 +1160,11 @@ shaka.media.StreamingEngine = class {
       shaka.log.v1(
           logPrefix, 'looking up segment from new stream endTime:', time);
 
+      // Using a new iterator means we need to resync the stream in sequence
+      // mode.  The buffered range might not align perfectly with the last
+      // segment end time, so we may end up repeating a segment.  Resyncing
+      // makes this safe to do.
+      mediaState.needsResync = true;
       mediaState.segmentIterator =
           mediaState.stream.segmentIndex.getIteratorForTime(time);
       const ref = mediaState.segmentIterator &&
@@ -1676,7 +1682,9 @@ shaka.media.StreamingEngine = class {
       const lastDiscontinuitySequence =
           mediaState.lastSegmentReference ?
               mediaState.lastSegmentReference.discontinuitySequence : null;
-      if (reference.discontinuitySequence != lastDiscontinuitySequence) {
+      if (reference.discontinuitySequence != lastDiscontinuitySequence ||
+          mediaState.needsResync) {
+        mediaState.needsResync = false;
         operations.push(this.playerInterface_.mediaSourceEngine.resync(
             mediaState.type, reference.startTime));
       }
@@ -2281,6 +2289,7 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   clearBufferSafeMargin: number,
  *   clearingBuffer: boolean,
  *   seeked: boolean,
+ *   needsResync: boolean,
  *   adaptation: boolean,
  *   recovering: boolean,
  *   hasError: boolean,
@@ -2326,10 +2335,13 @@ 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
+ * @property {boolean} seeked
  *   True indicates that the presentation just seeked.
-  * @property {boolean} adaptation
+ * @property {boolean} adaptation
  *   True indicates that the presentation just automatically switched variants.
+ * @property {boolean} needsResync
+ *   True indicates that the stream needs to be resynced in sequence mode,
+ *   regardless of discontinuity sequence.
  * @property {boolean} recovering
  *   True indicates that the last segment was not appended because it could not
  *   fit in the buffer.

package/lib/player.js

@@ -1537,6 +1537,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     has.startTime = null;
     has.uri = null;
 
+    // Release the region timeline, which is created when parsing the manifest.
+    if (this.regionTimeline_) {
+      this.regionTimeline_.release();
+      this.regionTimeline_ = null;
+    }
+
     // In most cases we should have a media element. The one exception would
     // be if there was an error and we, by chance, did not have a media element.
     if (has.mediaElement) {
@@ -6978,7 +6984,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.2-uncompiled';
+shaka.Player.version = 'v4.3.3-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/text/ui_text_displayer.js

@@ -371,6 +371,25 @@ shaka.text.UITextDisplayer = class {
     }
   }
 
+  /**
+   * Compute a unique internal id:
+   * Regions can reuse the id but have different dimensions, we need to
+   * consider those differences
+   * @param {shaka.extern.CueRegion} region
+   * @private
+   */
+  generateRegionId_(region) {
+    const percentageUnit = shaka.text.CueRegion.units.PERCENTAGE;
+    const heightUnit = region.heightUnits == percentageUnit ? '%' : 'px';
+    const viewportAnchorUnit =
+        region.viewportAnchorUnits == percentageUnit ? '%' : 'px';
+    const uniqueRegionId = `${region.id}_${
+      region.width}x${region.height}${heightUnit}-${
+      region.viewportAnchorX}x${region.viewportAnchorY}${viewportAnchorUnit}`;
+
+    return uniqueRegionId;
+  }
+
   /**
    * Get or create a region element corresponding to the cue region.  These are
    * cached by ID.
@@ -382,8 +401,9 @@ shaka.text.UITextDisplayer = class {
   getRegionElement_(cue) {
     const region = cue.region;
 
-    if (this.regionElements_.has(region.id)) {
-      return this.regionElements_.get(region.id);
+    const regionId = this.generateRegionId_(region);
+    if (this.regionElements_.has(regionId)) {
+      return this.regionElements_.get(regionId);
     }
 
     const regionElement = shaka.util.Dom.createHTMLElement('span');
@@ -394,7 +414,7 @@ shaka.text.UITextDisplayer = class {
     const viewportAnchorUnit =
         region.viewportAnchorUnits == percentageUnit ? '%' : 'px';
 
-    regionElement.id = 'shaka-text-region---' + region.id;
+    regionElement.id = 'shaka-text-region---' + regionId;
     regionElement.classList.add('shaka-text-region');
 
     regionElement.style.height = region.height + heightUnit;
@@ -415,7 +435,7 @@ shaka.text.UITextDisplayer = class {
       regionElement.style.justifyContent = 'flex-end';
     }
 
-    this.regionElements_.set(region.id, regionElement);
+    this.regionElements_.set(regionId, regionElement);
     return regionElement;
   }
 

package/lib/text/web_vtt_generator.js

@@ -81,16 +81,28 @@ shaka.text.WebVttGenerator = class {
     // We don't want to modify the array or objects passed in, since we don't
     // technically own them.  So we build a new array and replace certain items
     // in it if they need to be flattened.
-    const flattenedCues = cues.map((cue) => {
-      if (cue.nestedCues.length) {
-        const flatCue = cue.clone();
-        flatCue.nestedCues = [];
-        flatCue.payload = flattenPayload(cue);
-        return flatCue;
-      } else {
-        return cue;
+    // We also don't want to flatten the text payloads starting at a container
+    // element; otherwise, for containers encapsulating multiple caption lines,
+    // the lines would merge into a single cue. This is undesirable when a
+    // subset of the captions are outside of the append time window. To fix
+    // this, we only call flattenPayload() starting at elements marked as
+    // isContainer = false.
+    const getCuesToFlatten = (cues, result) => {
+      for (const cue of cues) {
+        if (cue.isContainer) {
+          // Recurse to find the actual text payload cues.
+          getCuesToFlatten(cue.nestedCues, result);
+        } else {
+          // Flatten the payload.
+          const flatCue = cue.clone();
+          flatCue.nestedCues = [];
+          flatCue.payload = flattenPayload(cue);
+          result.push(flatCue);
+        }
       }
-    });
+      return result;
+    };
+    const flattenedCues = getCuesToFlatten(cues, []);
 
     let webvttString = 'WEBVTT\n\n';
     for (const cue of flattenedCues) {

package/lib/util/dom_utils.js

@@ -36,7 +36,9 @@ shaka.util.Dom = class {
    * @return {!HTMLButtonElement}
    */
   static createButton() {
-    return /** @type {!HTMLButtonElement} */(document.createElement('button'));
+    const button = document.createElement('button');
+    button.setAttribute('type', 'button');
+    return /** @type {!HTMLButtonElement} */ (button);
   }
 
 

package/lib/util/stream_utils.js

@@ -459,12 +459,16 @@ shaka.util.StreamUtils = class {
           if (!Capabilities.isTypeSupported(audioFullType)) {
             return false;
           }
+          // Update the codec string with the (possibly) converted codecs.
+          videoCodecs = [videoCodecs, audioCodecs].join(',');
         }
         const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
             video.mimeType, videoCodecs, ContentType.VIDEO);
         if (!Capabilities.isTypeSupported(fullType)) {
           return false;
         }
+        // Update the codec string with the (possibly) converted codecs.
+        video.codecs = videoCodecs;
       }
       const audio = variant.audio;
       if (audio) {
@@ -475,6 +479,8 @@ shaka.util.StreamUtils = class {
         if (!Capabilities.isTypeSupported(fullType)) {
           return false;
         }
+        // Update the codec string with the (possibly) converted codecs.
+        audio.codecs = codecs;
       }
 
       // See: https://github.com/shaka-project/shaka-player/issues/3380

package/lib/util/timer.js

@@ -78,6 +78,11 @@ shaka.util.Timer = class {
   tickEvery(seconds) {
     this.stop();
 
+    if (goog.DEBUG) {
+      // Capture the stack trace by making a fake error.
+      const stackTrace = Error('Timer created').stack;
+      shaka.util.Timer.activeTimers.set(this, stackTrace);
+    }
     this.ticker_ = new shaka.util.DelayedTick(() => {
       // Schedule the timer again first. |onTick_| could cancel the timer and
       // rescheduling first simplifies the implementation.
@@ -99,5 +104,17 @@ shaka.util.Timer = class {
       this.ticker_.stop();
       this.ticker_ = null;
     }
+    if (goog.DEBUG) {
+      shaka.util.Timer.activeTimers.delete(this);
+    }
   }
 };
+
+if (goog.DEBUG) {
+  /**
+   * Tracks all active timer instances, along with the stack trace that created
+   * that timer.
+   * @type {!Map.<!shaka.util.Timer, string>}
+   */
+  shaka.util.Timer.activeTimers = new Map();
+}

package/package.json

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

package/test/hls/hls_live_unit.js

@@ -550,20 +550,24 @@ describe('HlsParser live', () => {
       });
     });
 
-    it('sets timestamp offset for segments with discontinuity', async () => {
+    it('sets discontinuity sequence numbers', async () => {
       const ref1 = makeReference(
           'test:/main.mp4', 0, 2, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
           /* timestampOffset= */ 0);
+      ref1.discontinuitySequence = 30;
 
-      // Expect the timestamp offset to be set for the segment after the
-      // EXT-X-DISCONTINUITY tag.
       const ref2 = makeReference(
           'test:/main2.mp4', 2, 4, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
           /* timestampOffset= */ 0);
+      ref2.discontinuitySequence = 31;
 
-      await testInitialManifest(master, mediaWithDiscontinuity, [ref1, ref2]);
+      const manifest = await testInitialManifest(
+          master, mediaWithDiscontinuity, [ref1, ref2]);
+
+      await testUpdate(
+          manifest, mediaWithUpdatedDiscontinuitySegment, [ref2]);
     });
 
     // Test for https://github.com/shaka-project/shaka-player/issues/4223
@@ -842,32 +846,6 @@ describe('HlsParser live', () => {
             shaka.net.NetworkingEngine.RequestType.MANIFEST);
       });
 
-      it('reuses cached timestamp offset for segments with discontinuity',
-          async () => {
-            const ref1 = makeReference(
-                'test:/main.mp4', 0, 2, /* syncTime= */ null);
-            const ref2 = makeReference(
-                'test:/main2.mp4', 2, 4, /* syncTime= */ null);
-
-            const manifest = await testInitialManifest(
-                master, mediaWithDiscontinuity, [ref1, ref2]);
-
-            fakeNetEngine.request.calls.reset();
-            await testUpdate(
-                manifest, mediaWithUpdatedDiscontinuitySegment, [ref2]);
-
-            // Only one request should be made, and it's for the playlist.
-            // Expect to use the cached timestamp offset for the main2.mp4
-            // segment, without fetching the start time again.
-            expect(fakeNetEngine.request).toHaveBeenCalledTimes(1);
-            fakeNetEngine.expectRequest(
-                'test:/video',
-                shaka.net.NetworkingEngine.RequestType.MANIFEST);
-            fakeNetEngine.expectNoRequest(
-                'test:/main.mp4',
-                shaka.net.NetworkingEngine.RequestType.SEGMENT);
-          });
-
       it('request playlist delta updates to skip segments', async () => {
         const mediaWithDeltaUpdates = [
           '#EXTM3U\n',

package/test/hls/hls_parser_unit.js

@@ -2669,6 +2669,9 @@ describe('HlsParser', () => {
       '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
       '#EXTINF:5,\n',
       '#EXT-X-BYTERANGE:121090@616\n',
+      'main.mp4\n',
+      '#EXTINF:5,\n',
+      '#EXT-X-BYTERANGE:121090@616\n',
       'main.mp4',
     ].join('');
 
@@ -2680,6 +2683,10 @@ describe('HlsParser', () => {
       '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
       '#EXTINF:5,\n',
       '#EXT-X-BYTERANGE:121090@616\n',
+      'main.mp4\n',
+      '#EXTINF:5,\n',
+      '#EXT-X-BYTERANGE:121090@616\n',
+      '#EXT-X-KEY:METHOD=NONE\n',
       'main.mp4',
     ].join('');
 
@@ -2689,6 +2696,9 @@ describe('HlsParser', () => {
       '#EXT-X-KEY:METHOD=AES-128,',
       'URI="800k.key"\n',
       '#EXTINF:5,\n',
+      'main.ts\n',
+      '#EXTINF:5,\n',
+      '#EXT-X-KEY:METHOD=NONE\n',
       'main.ts',
     ].join('');
 
@@ -2742,6 +2752,26 @@ describe('HlsParser', () => {
     const actual = await parser.start('test:/master', playerInterface);
     await loadAllStreamsFor(actual);
     expect(actual).toEqual(manifest);
+
+    const mp4AesEncryptionVideo = actual.variants[1].video;
+    await mp4AesEncryptionVideo.createSegmentIndex();
+    goog.asserts.assert(mp4AesEncryptionVideo.segmentIndex != null,
+        'Null segmentIndex!');
+
+    const firstMp4Segment = mp4AesEncryptionVideo.segmentIndex.get(0);
+    expect(firstMp4Segment.hlsAes128Key).toBeDefined();
+    const secondMp4Segment = mp4AesEncryptionVideo.segmentIndex.get(1);
+    expect(secondMp4Segment.hlsAes128Key).toBeNull();
+
+    const tsAesEncryptionVideo = actual.variants[2].video;
+    await tsAesEncryptionVideo.createSegmentIndex();
+    goog.asserts.assert(tsAesEncryptionVideo.segmentIndex != null,
+        'Null segmentIndex!');
+
+    const firstTsSegment = tsAesEncryptionVideo.segmentIndex.get(0);
+    expect(firstTsSegment.hlsAes128Key).toBeDefined();
+    const secondTsSegment = tsAesEncryptionVideo.segmentIndex.get(1);
+    expect(secondTsSegment.hlsAes128Key).toBeNull();
   });
 
   it('fails on AES-128 if WebCrypto APIs are not available', async () => {

package/test/media/segment_index_unit.js

@@ -532,6 +532,34 @@ describe('SegmentIndex', /** @suppress {accessControls} */ () => {
       goog.asserts.assert(position1 != null, 'Position should not be null!');
       expect(index1.get(position1)).toBe(references2[1]);
     });
+
+    it('does not duplicate references with rounding errors', () => {
+      /** @type {!Array.<!shaka.media.SegmentReference>} */
+      const references1 = [
+        makeReference(uri(10), 10, 20),
+        makeReference(uri(20), 20, 30),
+      ];
+      const index1 = new shaka.media.SegmentIndex(references1);
+
+      // 0.24 microseconds: an insignificant rounding error.
+      const tinyError = 0.24e-6;
+
+      /** @type {!Array.<!shaka.media.SegmentReference>} */
+      const references2 = [
+        makeReference(uri(10), 10, 20),
+        // The difference between this and the equivalent old reference is an
+        // insignificant rounding error.
+        makeReference(uri(20), 20 + tinyError, 30 + tinyError),
+        makeReference(uri(30), 30 + tinyError, 40),
+      ];
+
+      index1.merge(references2);
+      expect(index1.references.length).toBe(3);
+      expect(index1.references[0]).toEqual(references1[0]);
+      // The new references replaced the old one.
+      expect(index1.references[1]).toEqual(references2[1]);
+      expect(index1.references[2]).toEqual(references2[2]);
+    });
   });
 
   describe('evict', () => {