shaka-player 4.0.2 → 4.0.3

package/externs/shaka/player.js

@@ -766,8 +766,10 @@ shaka.extern.DashManifestConfiguration;
  *   <i>Defaults to <code>'avc1.42E01E'</code>.</i>
  * @property {boolean} ignoreManifestProgramDateTime
  *   If <code>true</code>, the HLS parser will ignore the
- *   <code>EXT-X-PROGRAM-DATE-TIME</code> tags in the manifest.
- *   Meant for tags that are incorrect or malformed.
+ *   <code>EXT-X-PROGRAM-DATE-TIME</code> tags in the manifest and use media
+ *   sequence numbers instead.
+ *   Meant for streams where <code>EXT-X-PROGRAM-DATE-TIME</code> is incorrect
+ *   or malformed.
  *   <i>Defaults to <code>false</code>.</i>
  * @property {string} mediaPlaylistFullMimeType
  *   A string containing a full mime type, including both the basic mime type

package/lib/hls/hls_parser.js

@@ -121,13 +121,19 @@ shaka.hls.HlsParser = class {
     this.updatePlaylistDelay_ = 0;
 
     /**
-     * A time offset to apply to EXT-X-PROGRAM-DATE-TIME values to normalize
-     * them so that they start at 0. This is necessary because these times will
-     * be used to set presentation times for segments.
-     * null means we don't have enough data yet.
+     * If true, we have already calculated offsets to synchronize streams.
+     * Offsets are computed in syncStreams*_().
+     * @private {boolean}
+     */
+    this.streamsSynced_ = false;
+
+    /**
+     * The minimum sequence number for generated segments, when ignoring
+     * EXT-X-PROGRAM-DATE-TIME.
+     *
      * @private {?number}
      */
-    this.syncTimeOffset_ = null;
+    this.minSequenceNumber_ = null;
 
     /**
      * This timer is used to trigger the start of a manifest update. A manifest
@@ -361,39 +367,155 @@ shaka.hls.HlsParser = class {
   }
 
   /**
-   * If necessary, makes sure that sync times will be normalized to 0, so that
-   * a stream does not start buffering at 50 years in because sync times are
-   * measured in time since 1970.
+   * Align all streams by sequence number by dropping early segments.  Then
+   * offset all streams to begin at presentation time 0.
    * @private
    */
-  calculateSyncTimeOffset_() {
-    if (this.syncTimeOffset_ != null) {
-      // The offset was already calculated.
+  syncStreamsWithSequenceNumber_() {
+    if (this.streamsSynced_) {
       return;
     }
 
-    const segments = new Set();
-    let lowestSyncTime = Infinity;
+    // Sync using media sequence number.  Find the highest starting sequence
+    // number among all streams.  Later, we will drop any references to
+    // earlier segments in other streams, then offset everything back to 0.
+    let highestStartingSequenceNumber = -1;
+    const firstSequenceNumberMap = new Map();
+
     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
       const segmentIndex = streamInfo.stream.segmentIndex;
       if (segmentIndex) {
-        segmentIndex.forEachTopLevelReference((segment) => {
-          if (segment.syncTime != null) {
-            lowestSyncTime = Math.min(lowestSyncTime, segment.syncTime);
-            segments.add(segment);
+        const segment0 = segmentIndex.earliestReference();
+        if (segment0) {
+          // This looks inefficient, but iteration order is insertion order.
+          // So the very first entry should be the one we want.
+          // We assert that this holds true so that we are alerted by debug
+          // builds and tests if it changes.  We still do a loop, though, so
+          // that the code functions correctly in production no matter what.
+          if (goog.DEBUG) {
+            const firstSequenceStartTime =
+                streamInfo.mediaSequenceToStartTime.values().next().value;
+            goog.asserts.assert(
+                firstSequenceStartTime == segment0.startTime,
+                'Sequence number map is not ordered as expected!');
+          }
+          for (const [sequence, start] of streamInfo.mediaSequenceToStartTime) {
+            if (start == segment0.startTime) {
+              firstSequenceNumberMap.set(streamInfo, sequence);
+
+              highestStartingSequenceNumber = Math.max(
+                  highestStartingSequenceNumber, sequence);
+              break;
+            }
           }
-        });
+        }
+      }
+    }
+
+    if (highestStartingSequenceNumber < 0) {
+      // Nothing to sync.
+      return;
+    }
+
+    // From now on, updates will ignore any references before this number.
+    this.minSequenceNumber_ = highestStartingSequenceNumber;
+
+    shaka.log.debug('Syncing HLS streams against base sequence number:',
+        this.minSequenceNumber_);
+
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      const segmentIndex = streamInfo.stream.segmentIndex;
+      if (segmentIndex) {
+        // Drop any earlier references.
+        const numSegmentsToDrop = this.minSequenceNumber_ -
+            firstSequenceNumberMap.get(streamInfo);
+        segmentIndex.dropFirstReferences(numSegmentsToDrop);
+
+        // Now adjust timestamps back to begin at 0.
+        const segmentN = segmentIndex.earliestReference();
+        if (segmentN) {
+          this.offsetStream_(streamInfo, -segmentN.startTime);
+        }
+      }
+    }
+
+    this.streamsSynced_ = true;
+  }
+
+  /**
+   * Synchronize streams by the EXT-X-PROGRAM-DATE-TIME tags attached to their
+   * segments.  Also normalizes segment times so that the earliest segment in
+   * any stream is at time 0.
+   * @private
+   */
+  syncStreamsWithProgramDateTime_() {
+    if (this.streamsSynced_) {
+      return;
+    }
+
+    let lowestSyncTime = Infinity;
+
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      const segmentIndex = streamInfo.stream.segmentIndex;
+      if (segmentIndex) {
+        const segment0 = segmentIndex.earliestReference();
+        if (segment0 != null && segment0.syncTime != null) {
+          lowestSyncTime = Math.min(lowestSyncTime, segment0.syncTime);
+        }
       }
     }
-    if (segments.size > 0) {
-      this.syncTimeOffset_ = -lowestSyncTime;
-      for (const segment of segments) {
-        segment.syncTime += this.syncTimeOffset_;
-        for (const partial of segment.partialReferences) {
-          partial.syncTime += this.syncTimeOffset_;
+
+    if (lowestSyncTime == Infinity) {
+      // Nothing to sync.
+      return;
+    }
+
+    shaka.log.debug('Syncing HLS streams against base time:', lowestSyncTime);
+
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      const segmentIndex = streamInfo.stream.segmentIndex;
+      if (segmentIndex != null) {
+        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.
+          const segment0TargetTime = segment0.syncTime - lowestSyncTime;
+          const streamOffset = segment0TargetTime - segment0.startTime;
+
+          this.offsetStream_(streamInfo, streamOffset);
         }
       }
     }
+
+    this.streamsSynced_ = true;
+  }
+
+  /**
+   * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
+   * @param {number} offset
+   * @private
+   */
+  offsetStream_(streamInfo, offset) {
+    streamInfo.stream.segmentIndex.offset(offset);
+
+    streamInfo.maxTimestamp += offset;
+    goog.asserts.assert(streamInfo.maxTimestamp >= 0,
+        'Negative maxTimestamp after adjustment!');
+
+    for (const [key, value] of streamInfo.mediaSequenceToStartTime) {
+      streamInfo.mediaSequenceToStartTime.set(key, value + offset);
+    }
+
+    shaka.log.debug('Offset', offset, 'applied to',
+        streamInfo.verbatimMediaPlaylistUri);
   }
 
   /**
@@ -524,7 +646,11 @@ shaka.hls.HlsParser = class {
 
     // Now that we have generated all streams, we can determine the offset to
     // apply to sync times.
-    this.calculateSyncTimeOffset_();
+    if (this.config_.hls.ignoreManifestProgramDateTime) {
+      this.syncStreamsWithSequenceNumber_();
+    } else {
+      this.syncStreamsWithProgramDateTime_();
+    }
 
     if (this.aesEncrypted_ && variants.length == 0) {
       // We do not support AES-128 encryption with HLS yet. Variants is null
@@ -539,15 +665,12 @@ shaka.hls.HlsParser = class {
 
     // Find the min and max timestamp of the earliest segment in all streams.
     // Find the minimum duration of all streams as well.
-    let minFirstTimestamp = Infinity;
     let minDuration = Infinity;
-
     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
-      minFirstTimestamp =
-          Math.min(minFirstTimestamp, streamInfo.minTimestamp);
       if (streamInfo.stream.type != 'text') {
-        minDuration = Math.min(minDuration,
-            streamInfo.maxTimestamp - streamInfo.minTimestamp);
+        // Since everything is already offset to 0 (either by sync or by being
+        // VOD), only maxTimestamp is necessary to compute the duration.
+        minDuration = Math.min(minDuration, streamInfo.maxTimestamp);
       }
     }
 
@@ -591,18 +714,11 @@ shaka.hls.HlsParser = class {
             segmentAvailabilityDuration);
       }
     } else {
-      // For VOD/EVENT content, offset everything back to 0.
-      // Use the minimum timestamp as the offset for all streams.
       // Use the minimum duration as the presentation duration.
       this.presentationTimeline_.setDuration(minDuration);
-      // Use a negative offset to adjust towards 0.
-      this.presentationTimeline_.offset(-minFirstTimestamp);
 
       for (const streamInfo of this.uriToStreamInfosMap_.values()) {
-        // The segments were created with actual media times, rather than
-        // presentation-aligned times, so offset them all now.
-        streamInfo.stream.segmentIndex.offset(-minFirstTimestamp);
-        // Finally, fit the segments to the playlist duration.
+        // Fit the segments to the playlist duration.
         streamInfo.stream.segmentIndex.fit(/* periodStart= */ 0, minDuration);
       }
     }
@@ -810,12 +926,7 @@ shaka.hls.HlsParser = class {
     });
 
     // Create stream info for each audio / video media tag.
-    // Wait for the first stream info created, so that the start time is fetched
-    // and can be reused.
-    if (mediaTags.length) {
-      await this.createStreamInfoFromMediaTag_(mediaTags[0]);
-    }
-    const promises = mediaTags.slice(1).map((tag) => {
+    const promises = mediaTags.map((tag) => {
       return this.createStreamInfoFromMediaTag_(tag);
     });
     await Promise.all(promises);
@@ -1583,7 +1694,6 @@ shaka.hls.HlsParser = class {
       throw error;
     }
 
-    const minTimestamp = segments[0].startTime;
     const lastEndTime = segments[segments.length - 1].endTime;
     /** @type {!shaka.media.SegmentIndex} */
     const segmentIndex = new shaka.media.SegmentIndex(segments);
@@ -1641,7 +1751,6 @@ shaka.hls.HlsParser = class {
       stream,
       verbatimMediaPlaylistUri,
       absoluteMediaPlaylistUri,
-      minTimestamp,
       maxTimestamp: lastEndTime,
       mediaSequenceToStartTime,
       canSkipSegments,
@@ -1853,15 +1962,9 @@ shaka.hls.HlsParser = class {
       const dateTimeTag =
           shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-PROGRAM-DATE-TIME');
       if (dateTimeTag && dateTimeTag.value) {
-        const time = shaka.util.XmlUtils.parseDate(dateTimeTag.value);
-        goog.asserts.assert(time != null,
+        syncTime = shaka.util.XmlUtils.parseDate(dateTimeTag.value);
+        goog.asserts.assert(syncTime != null,
             'EXT-X-PROGRAM-DATE-TIME format not valid');
-        // Sync time offset is null on the first go-through. This indicates that
-        // we have not yet seen every stream, and thus do not yet have enough
-        // information to determine how to normalize the sync times.
-        // For that first go-through, the sync time will be applied after the
-        // references are all created. Until then, just offset by 0.
-        syncTime = time + (this.syncTimeOffset_ || 0);
       }
     }
 
@@ -2085,16 +2188,13 @@ shaka.hls.HlsParser = class {
       firstStartTime = mediaSequenceToStartTime.get(position);
     }
 
-    const firstSegmentUri = hlsSegments[0].absoluteUri;
-    shaka.log.debug('First segment', firstSegmentUri.split('/').pop(),
-        'starts at', firstStartTime);
-
     /** @type {!Array.<!shaka.media.SegmentReference>} */
     const references = [];
 
+    let previousReference = null;
+
     for (let i = 0; i < hlsSegments.length; i++) {
       const item = hlsSegments[i];
-      const previousReference = references[references.length - 1];
       const startTime =
           (i == 0) ? firstStartTime : previousReference.endTime;
       position = mediaSequenceNumber + skippedSegments + i;
@@ -2124,9 +2224,17 @@ shaka.hls.HlsParser = class {
           variables,
           playlist.absoluteUri,
           type);
+      previousReference = reference;
 
       if (reference) {
-        references.push(reference);
+        if (this.config_.hls.ignoreManifestProgramDateTime &&
+            this.minSequenceNumber_ != null &&
+            position < this.minSequenceNumber_) {
+          // This segment is ignored as part of our fallback synchronization
+          // method.
+        } else {
+          references.push(reference);
+        }
       }
     }
 
@@ -2256,12 +2364,16 @@ shaka.hls.HlsParser = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
+    // If you wait long enough, requesting the first segment can fail
+    // because it has fallen off the left edge of DVR, so to be safer,
+    // let's request the middle segment.
     goog.asserts.assert(playlist.segments.length,
         'Playlist should have segments!');
-    const firstSegmentUri = this.variableSubstitution_(
-        playlist.segments[0].absoluteUri, variables);
+    const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
+    const middleSegmentUri = this.variableSubstitution_(
+        playlist.segments[middleSegmentIdx].absoluteUri, variables);
 
-    const parsedUri = new goog.Uri(firstSegmentUri);
+    const parsedUri = new goog.Uri(middleSegmentUri);
     const extension = parsedUri.getPath().split('.').pop();
     const map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
 
@@ -2291,7 +2403,7 @@ shaka.hls.HlsParser = class {
     // If unable to guess mime type, request a segment and try getting it
     // from the response.
     const headRequest = shaka.net.NetworkingEngine.makeRequest(
-        [firstSegmentUri], this.config_.retryParameters);
+        [middleSegmentUri], this.config_.retryParameters);
     headRequest.method = 'HEAD';
 
     const response = await this.makeNetworkRequest_(
@@ -2578,7 +2690,6 @@ shaka.hls.HlsParser = class {
  *   stream: !shaka.extern.Stream,
  *   verbatimMediaPlaylistUri: string,
  *   absoluteMediaPlaylistUri: string,
- *   minTimestamp: number,
  *   maxTimestamp: number,
  *   mediaSequenceToStartTime: !Map.<number, number>,
  *   canSkipSegments: boolean
@@ -2597,8 +2708,6 @@ shaka.hls.HlsParser = class {
  * @property {string} absoluteMediaPlaylistUri
  *   The absolute media playlist URI, resolved relative to the master playlist
  *   and updated to reflect any redirects.
- * @property {number} minTimestamp
- *   The minimum timestamp found in the stream.
  * @property {number} maxTimestamp
  *   The maximum timestamp found in the stream.
  * @property {!Map.<number, number>} mediaSequenceToStartTime

package/lib/media/segment_index.js

@@ -94,6 +94,25 @@ shaka.media.SegmentIndex = class {
   }
 
 
+  /**
+   * Return the earliest reference, or null if empty.
+   * @return {shaka.media.SegmentReference}
+   */
+  earliestReference() {
+    return this.references[0] || null;
+  }
+
+
+  /**
+   * Drop the first N references.
+   * Used in early HLS synchronization, and does not count as eviction.
+   * @param {number} n
+   */
+  dropFirstReferences(n) {
+    this.references.splice(0, n);
+  }
+
+
   /**
    * Finds the position of the segment for the given time, in seconds, relative
    * to the start of the presentation.  Returns the position of the segment
@@ -166,7 +185,13 @@ shaka.media.SegmentIndex = class {
       for (const ref of this.references) {
         ref.startTime += offset;
         ref.endTime += offset;
-        ref.timestampOffset += offset;
+        ref.trueEndTime += offset;
+
+        for (const partial of ref.partialReferences) {
+          partial.startTime += offset;
+          partial.endTime += offset;
+          partial.trueEndTime += offset;
+        }
       }
     }
   }

package/lib/media/segment_reference.js

@@ -160,8 +160,9 @@ shaka.media.SegmentReference = class {
    *  If not provided, the duration should be automatically calculated based on
    *  the duration of the reference.
    * @param {?number=} syncTime
-   *  A time value, expressed in the same scale as the start and end time, which
-   *  is used to synchronize between streams.
+   *  A time value, expressed in seconds since 1970, which is used to
+   *  synchronize between streams.  Both produced and consumed by the HLS
+   *  parser.  Other components should not need this value.
    * @param {shaka.media.SegmentReference.Status=} status
    *  The segment status is used to indicate that a segment does not exist or is
    *  not available.
@@ -221,7 +222,13 @@ shaka.media.SegmentReference = class {
     /** @type {?number} */
     this.tileDuration = tileDuration;
 
-    /** @type {?number} */
+    /**
+     * A time value, expressed in seconds since 1970, which is used to
+     * synchronize between streams.  Both produced and consumed by the HLS
+     * parser.  Other components should not need this value.
+     *
+     * @type {?number}
+     */
     this.syncTime = syncTime;
 
     /** @type {shaka.media.SegmentReference.Status} */

package/lib/media/streaming_engine.js

@@ -1602,7 +1602,7 @@ shaka.media.StreamingEngine = class {
     await this.playerInterface_.mediaSourceEngine.appendBuffer(
         mediaState.type,
         segment,
-        reference.syncTime == null ? reference.startTime : reference.syncTime,
+        reference.startTime,
         reference.endTime,
         hasClosedCaptions,
         seeked);

package/lib/player.js

@@ -6450,7 +6450,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.0.2-uncompiled';
+shaka.Player.version = 'v4.0.3-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/util/stream_utils.js

@@ -1008,6 +1008,7 @@ shaka.util.StreamUtils = class {
       track.channelsCount = audio.channelsCount;
       track.audioSamplingRate = audio.audioSamplingRate;
       track.audioBandwidth = audio.bandwidth || null;
+      track.spatialAudio = audio.spatialAudio;
       track.label = audio.label;
       track.audioRoles = audio.roles;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [
@@ -96,7 +96,7 @@
     "prepublishOnly": "python build/checkversion.py && python build/all.py --force"
   },
   "dependencies": {
-    "eme-encryption-scheme-polyfill": "^2.0.3"
+    "eme-encryption-scheme-polyfill": "^2.0.5"
   },
   "engines": {
     "node": ">=14"

package/test/hls/hls_parser_unit.js

@@ -2021,6 +2021,10 @@ describe('HlsParser', () => {
   });
 
   describe('produces syncTime', () => {
+    // Corresponds to "2000-01-01T00:00:00.00Z".
+    // All the PROGRAM-DATE-TIME values in the tests below are at or after this.
+    const syncTimeBase = 946684800;
+
     /**
      * @param {number} startTime
      * @param {number} endTime
@@ -2039,9 +2043,10 @@ describe('HlsParser', () => {
     /**
      * @param {string} media
      * @param {!Array.<number>} startTimes
+     * @param {number} syncTimeOffset
      * @param {(function(!shaka.media.SegmentReference))=} modifyFn
      */
-    async function test(media, startTimes, modifyFn) {
+    async function test(media, startTimes, syncTimeOffset, modifyFn) {
       const master = [
         '#EXTM3U\n',
         '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1,vtt",',
@@ -2053,7 +2058,8 @@ describe('HlsParser', () => {
       for (let i = 0; i < startTimes.length - 1; i++) {
         const startTime = startTimes[i];
         const endTime = startTimes[i + 1];
-        const reference = makeReference(startTime, endTime, startTime);
+        const reference = makeReference(
+            startTime, endTime, syncTimeOffset + startTime);
         if (modifyFn) {
           modifyFn(reference);
         }
@@ -2100,7 +2106,7 @@ describe('HlsParser', () => {
         '#EXT-X-PROGRAM-DATE-TIME:2000-01-01T00:00:25.00Z\n',
         '#EXTINF:5,\n',
         'main.mp4',
-      ].join(''), [0, 5, 10, 15, 20, 25]);
+      ].join(''), [0, 5, 10, 15, 20, 25], syncTimeBase + 5);
     });
 
     it('when some EXT-X-PROGRAM-DATE-TIME values are missing', async () => {
@@ -2122,7 +2128,7 @@ describe('HlsParser', () => {
         'main.mp4\n',
         '#EXTINF:4,\n',
         'main.mp4',
-      ].join(''), [0, 2, 7, 12, 17, 19, 23]);
+      ].join(''), [0, 2, 7, 12, 17, 19, 23], syncTimeBase + 8);
     });
 
     it('except when ignoreManifestProgramDateTime is set', async () => {
@@ -2148,7 +2154,7 @@ describe('HlsParser', () => {
         '#EXT-X-PROGRAM-DATE-TIME:2000-01-01T00:00:25.00Z\n',
         '#EXTINF:5,\n',
         'main.mp4',
-      ].join(''), [0, 5, 10, 15, 20, 25], (reference) => {
+      ].join(''), [0, 5, 10, 15, 20, 25], syncTimeBase + 5, (reference) => {
         reference.syncTime = null;
       });
     });
@@ -2176,11 +2182,11 @@ describe('HlsParser', () => {
         '#EXT-X-PROGRAM-DATE-TIME:2000-01-01T00:00:25.00Z\n',
         '#EXTINF:5,\n',
         'main.mp4',
-      ].join(''), [0, 5, 10, 15, 20, 25], (reference) => {
+      ].join(''), [0, 5, 10, 15, 20, 25], syncTimeBase + 5, (reference) => {
         if (reference.startTime == 10) {
           reference.partialReferences = [
-            makeReference(10, 12.5, 10),
-            makeReference(12.5, 15, 12.5),
+            makeReference(10, 12.5, syncTimeBase + 15),
+            makeReference(12.5, 15, syncTimeBase + 17.5),
           ];
         }
       });
@@ -3555,4 +3561,92 @@ describe('HlsParser', () => {
 
     await testHlsParser(media, '', manifest);
   });
+
+  it('syncs on sequence with ignoreManifestProgramDateTime', async () => {
+    const config = shaka.util.PlayerConfiguration.createDefault().manifest;
+    config.hls.ignoreManifestProgramDateTime = true;
+    parser.configure(config);
+
+    const master = [
+      '#EXTM3U\n',
+      '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="eng",URI="audio"\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1,mp4a",',
+      'RESOLUTION=960x540,FRAME-RATE=60,AUDIO="aud1"\n',
+      'video\n',
+    ].join('');
+
+    const video = [
+      '#EXTM3U\n',
+      '#EXT-X-TARGETDURATION:5\n',
+      '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+      '#EXT-X-MEDIA-SEQUENCE:1\n',
+      '#EXTINF:5,\n',
+      'video1.mp4\n',
+      '#EXTINF:5,\n',
+      'video2.mp4\n',
+      '#EXTINF:5,\n',
+      'video3.mp4\n',
+    ].join('');
+
+    const audio = [
+      '#EXTM3U\n',
+      '#EXT-X-TARGETDURATION:5\n',
+      '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+      '#EXT-X-MEDIA-SEQUENCE:3\n',
+      '#EXTINF:5,\n',
+      'audio3.mp4\n',
+      '#EXTINF:5,\n',
+      'audio4.mp4\n',
+    ].join('');
+
+    const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+      manifest.sequenceMode = true;
+      manifest.anyTimeline();
+      manifest.addPartialVariant((variant) => {
+        variant.language = 'en';
+        variant.bandwidth = 200;
+        variant.addPartialStream(ContentType.VIDEO, (stream) => {
+          stream.mime('video/mp4', 'avc1');
+          stream.size(960, 540);
+          stream.frameRate = 60;
+        });
+        variant.addPartialStream(ContentType.AUDIO, (stream) => {
+          stream.language = 'en';
+          stream.mime('audio/mp4', 'mp4a');
+        });
+      });
+    });
+
+    fakeNetEngine
+        .setResponseText('test:/master', master)
+        .setResponseText('test:/audio', audio)
+        .setResponseText('test:/video', video)
+        .setResponseValue('test:/init.mp4', initSegmentData);
+
+    const actualManifest = await parser.start('test:/master', playerInterface);
+    expect(actualManifest).toEqual(manifest);
+
+    const actualVideo = actualManifest.variants[0].video;
+    await actualVideo.createSegmentIndex();
+    goog.asserts.assert(actualVideo.segmentIndex != null, 'Null segmentIndex!');
+
+    const actualAudio = actualManifest.variants[0].audio;
+    await actualAudio.createSegmentIndex();
+    goog.asserts.assert(actualAudio.segmentIndex != null, 'Null segmentIndex!');
+
+    // Verify that the references are aligned on sequence number.
+    const videoSegments = Array.from(actualVideo.segmentIndex);
+    const audioSegments = Array.from(actualAudio.segmentIndex);
+
+    // The first two were dropped to align with the audio.
+    expect(videoSegments.map((ref) => ref.getUris()[0])).toEqual([
+      'test:/video3.mp4',
+    ]);
+    // Audio has a 4th segment that video doesn't, but that doesn't get clipped
+    // or used as the base.  Alignment is truly based on media sequence number.
+    expect(audioSegments.map((ref) => ref.getUris()[0])).toEqual([
+      'test:/audio3.mp4',
+      'test:/audio4.mp4',
+    ]);
+  });
 });