shaka-player 4.3.5 → 4.3.6

package/lib/media/streaming_engine.js

@@ -78,6 +78,9 @@ shaka.media.StreamingEngine = class {
     /** @private {?shaka.extern.Stream} */
     this.currentTextStream_ = null;
 
+    /** @private {number} */
+    this.textStreamSequenceId_ = 0;
+
     /** @private {boolean} */
     this.parsedPrftEventRaised_ = false;
 
@@ -224,6 +227,8 @@ shaka.media.StreamingEngine = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     goog.asserts.assert(!this.mediaStates_.has(ContentType.TEXT),
         'Should not call loadNewTextStream_ while streaming text!');
+    this.textStreamSequenceId_++;
+    const currentSequenceId = this.textStreamSequenceId_;
 
     try {
       // Clear MediaSource's buffered text, so that the new text stream will
@@ -246,7 +251,7 @@ shaka.media.StreamingEngine = class {
     const streamText =
         textDisplayer.isTextVisible() || this.config_.alwaysStreamText;
 
-    if (streamText) {
+    if (streamText && (this.textStreamSequenceId_ == currentSequenceId)) {
       const state = this.createMediaState_(stream);
       this.mediaStates_.set(ContentType.TEXT, state);
       this.scheduleUpdate_(state, 0);
@@ -357,7 +362,7 @@ shaka.media.StreamingEngine = class {
   /**
    * @param {shaka.extern.Stream} textStream
    */
-  switchTextStream(textStream) {
+  async switchTextStream(textStream) {
     this.currentTextStream_ = textStream;
 
     if (!this.startupComplete_) {
@@ -369,6 +374,13 @@ shaka.media.StreamingEngine = class {
     goog.asserts.assert(textStream && textStream.type == ContentType.TEXT,
         'Wrong stream type passed to switchTextStream!');
 
+    // In HLS it is possible that the mimetype changes when the media
+    // playlist is downloaded, so it is necessary to have the updated data
+    // here.
+    if (!textStream.segmentIndex) {
+      await textStream.createSegmentIndex();
+    }
+
     this.switchInternal_(
         textStream, /* clearBuffer= */ true,
         /* safeMargin= */ 0, /* force= */ false);
@@ -1564,10 +1576,10 @@ shaka.media.StreamingEngine = class {
           'waiting for another stream to recover...');
     }
 
-    // QuotaExceededError gets thrown if evication didn't help to make room
+    // QuotaExceededError gets thrown if eviction didn't help to make room
     // for a segment. We want to wait for a while (4 seconds is just an
     // arbitrary number) before updating to give the playhead a chance to
-    // advance, so we don't immidiately throw again.
+    // advance, so we don't immediately throw again.
     this.scheduleUpdate_(mediaState, 4);
   }
 
@@ -1675,19 +1687,31 @@ shaka.media.StreamingEngine = class {
       }
     }
 
+    const lastDiscontinuitySequence =
+        mediaState.lastSegmentReference ?
+            mediaState.lastSegmentReference.discontinuitySequence : null;
     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 ||
           mediaState.needsResync) {
         mediaState.needsResync = false;
         operations.push(this.playerInterface_.mediaSourceEngine.resync(
             mediaState.type, reference.startTime));
       }
+    } else {
+      // In segments mode, we need to resync to set the timestampOffset
+      // to the start of the current discontinuity sequence. This is
+      // because individual discontinuity sequences may have internal
+      // timestamps that overlap, so we adjust the timestampOffset to avoid
+      // having the SourceBuffer get overwritten.
+      if (reference.discontinuitySequence != lastDiscontinuitySequence) {
+        operations.push(
+            this.playerInterface_.mediaSourceEngine.resync(
+                mediaState.type,
+                reference.timestampOffset));
+      }
     }
 
     await Promise.all(operations);

package/lib/net/http_fetch_plugin.js

@@ -120,65 +120,77 @@ shaka.net.HttpFetchPlugin = class {
       // not the body yet.
       headersReceived(shaka.net.HttpFetchPlugin.headersToGenericObject_(
           response.headers));
-      // Getting the reader in this way allows us to observe the process of
-      // downloading the body, instead of just waiting for an opaque promise to
-      // resolve.
-      // We first clone the response because calling getReader locks the body
-      // stream; if we didn't clone it here, we would be unable to get the
-      // response's arrayBuffer later.
-      const reader = response.clone().body.getReader();
-
-      const contentLengthRaw = response.headers.get('Content-Length');
-      const contentLength =
-          contentLengthRaw ? parseInt(contentLengthRaw, 10) : 0;
-
-      const start = (controller) => {
-        const push = async () => {
-          let readObj;
-          try {
-            readObj = await reader.read();
-          } catch (e) {
-            // If we abort the request, we'll get an error here.  Just ignore it
-            // since real errors will be reported when we read the buffer below.
-            shaka.log.v1('error reading from stream', e.message);
-            return;
-          }
-
-          if (!readObj.done) {
-            loaded += readObj.value.byteLength;
-            if (streamDataCallback) {
-              await streamDataCallback(readObj.value);
+
+      // In new versions of Chromium, HEAD requests now have a response body
+      // that is null.
+      // So just don't try to download the body at all, if it's a HEAD request,
+      // to avoid null reference errors.
+      // See: https://crbug.com/1297060
+      if (init.method != 'HEAD') {
+        goog.asserts.assert(response.body,
+            'non-HEAD responses should have a body');
+
+        // Getting the reader in this way allows us to observe the process of
+        // downloading the body, instead of just waiting for an opaque promise
+        // to resolve.
+        // We first clone the response because calling getReader locks the body
+        // stream; if we didn't clone it here, we would be unable to get the
+        // response's arrayBuffer later.
+        const reader = response.clone().body.getReader();
+
+        const contentLengthRaw = response.headers.get('Content-Length');
+        const contentLength =
+            contentLengthRaw ? parseInt(contentLengthRaw, 10) : 0;
+
+        const start = (controller) => {
+          const push = async () => {
+            let readObj;
+            try {
+              readObj = await reader.read();
+            } catch (e) {
+              // If we abort the request, we'll get an error here.  Just ignore
+              // it since real errors will be reported when we read the buffer
+              // below.
+              shaka.log.v1('error reading from stream', e.message);
+              return;
+            }
+
+            if (!readObj.done) {
+              loaded += readObj.value.byteLength;
+              if (streamDataCallback) {
+                await streamDataCallback(readObj.value);
+              }
+            }
+
+            const currentTime = Date.now();
+            // If the time between last time and this time we got progress event
+            // is long enough, or if a whole segment is downloaded, call
+            // progressUpdated().
+            if (currentTime - lastTime > 100 || readObj.done) {
+              progressUpdated(currentTime - lastTime, loaded - lastLoaded,
+                  contentLength - loaded);
+              lastLoaded = loaded;
+              lastTime = currentTime;
+            }
+
+            if (readObj.done) {
+              goog.asserts.assert(!readObj.value,
+                  'readObj should be unset when "done" is true.');
+              controller.close();
+            } else {
+              controller.enqueue(readObj.value);
+              push();
             }
-          }
-
-          const currentTime = Date.now();
-          // If the time between last time and this time we got progress event
-          // is long enough, or if a whole segment is downloaded, call
-          // progressUpdated().
-          if (currentTime - lastTime > 100 || readObj.done) {
-            progressUpdated(currentTime - lastTime, loaded - lastLoaded,
-                contentLength - loaded);
-            lastLoaded = loaded;
-            lastTime = currentTime;
-          }
-
-          if (readObj.done) {
-            goog.asserts.assert(!readObj.value,
-                'readObj should be unset when "done" is true.');
-            controller.close();
-          } else {
-            controller.enqueue(readObj.value);
-            push();
-          }
+          };
+          push();
         };
-        push();
-      };
-      // Create a ReadableStream to use the reader. We don't need to use the
-      // actual stream for anything, though, as we are using the response's
-      // arrayBuffer method to get the body, so we don't store the
-      // ReadableStream.
-      new ReadableStream({start}); // eslint-disable-line no-new
-      arrayBuffer = await response.arrayBuffer();
+        // Create a ReadableStream to use the reader. We don't need to use the
+        // actual stream for anything, though, as we are using the response's
+        // arrayBuffer method to get the body, so we don't store the
+        // ReadableStream.
+        new ReadableStream({start}); // eslint-disable-line no-new
+        arrayBuffer = await response.arrayBuffer();
+      }
     } catch (error) {
       if (abortStatus.canceled) {
         throw new shaka.util.Error(
@@ -243,6 +255,16 @@ shaka.net.HttpFetchPlugin = class {
     } else {
       return false;
     }
+    // Old fetch implementations hasn't body and ReadableStream implementation
+    // See: https://github.com/shaka-project/shaka-player/issues/5088
+    if (window.Response) {
+      const response = new Response('');
+      if (!response.body) {
+        return false;
+      }
+    } else {
+      return false;
+    }
     return !!(window.fetch && window.AbortController);
   }
 };

package/lib/net/networking_engine.js

@@ -312,6 +312,7 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
       if (!responseAndGotProgress.gotProgress &&
           this.onProgressUpdated_ &&
           !response.fromCache &&
+          request.method != 'HEAD' &&
           type == shaka.net.NetworkingEngine.RequestType.SEGMENT) {
         this.onProgressUpdated_(response.timeMs, response.data.byteLength);
       }

package/lib/player.js

@@ -897,7 +897,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     this.abrManagerFactory_ = null;
-    this.abrManager_ = null;
     this.config_ = null;
     this.stats_ = null;
     this.videoContainer_ = null;
@@ -908,6 +907,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.networkingEngine_ = null;
     }
 
+    if (this.abrManager_) {
+      this.abrManager_.release();
+      this.abrManager_ = null;
+    }
+
     // FakeEventTarget implements IReleasable
     super.release();
   }
@@ -1342,6 +1346,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    */
   shouldUseSrcEquals_(payload) {
     const Platform = shaka.util.Platform;
+    const MimeUtils = shaka.util.MimeUtils;
 
     // If we are using a platform that does not support media source, we will
     // fall back to src= to handle all playback.
@@ -1396,7 +1401,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // version there.
 
       // Native HLS can be preferred on any platform via this flag:
-      if (this.config_.streaming.preferNativeHls) {
+      if (MimeUtils.isHlsType(mimeType) &&
+          this.config_.streaming.preferNativeHls) {
         return true;
       }
 
@@ -4276,6 +4282,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               firstVariantWithLabel.language, '', 0, label);
 
       this.chooseVariantAndSwitch_();
+    } else if (this.video_ && this.video_.audioTracks) {
+      const audioTracks = Array.from(this.video_.audioTracks);
+
+      let trackMatch = null;
+
+      for (const audioTrack of audioTracks) {
+        if (audioTrack.label == label) {
+          trackMatch = audioTrack;
+        }
+      }
+      if (trackMatch) {
+        this.switchHtml5Track_(trackMatch);
+      }
     }
   }
 
@@ -6986,7 +7005,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.5-uncompiled';
+shaka.Player.version = 'v4.3.6-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/media_capabilities.js

@@ -119,6 +119,19 @@ shaka.polyfill.MediaCapabilities = class {
         if (shaka.util.Platform.isChromecast()) {
           isSupported =
               shaka.polyfill.MediaCapabilities.canCastDisplayType_(videoConfig);
+        } else if (shaka.util.Platform.isTizen()) {
+          let extendedType = videoConfig.contentType;
+          if (videoConfig.width && videoConfig.height) {
+            extendedType += `; width=${videoConfig.width}`;
+            extendedType += `; height=${videoConfig.height}`;
+          }
+          if (videoConfig.framerate) {
+            extendedType += `; framerate=${videoConfig.framerate}`;
+          }
+          if (videoConfig.bitrate) {
+            extendedType += `; bitrate=${videoConfig.bitrate}`;
+          }
+          isSupported = Capabilities.isTypeSupported(extendedType);
         } else {
           isSupported = Capabilities.isTypeSupported(videoConfig.contentType);
         }

package/lib/text/mp4_vtt_parser.js

@@ -97,6 +97,10 @@ shaka.text.Mp4VttParser = class {
    * @export
    */
   parseMedia(data, time) {
+    if (!data.length) {
+      return [];
+    }
+
     if (!this.timescale_) {
       // Missing timescale for VTT content. We should have seen the init
       // segment.

package/lib/text/text_engine.js

@@ -139,6 +139,7 @@ shaka.text.TextEngine = class {
     // into TextEngine and TextDisplayer.
     if (mimeType == shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE ||
         mimeType == shaka.util.MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE) {
+      this.parser_ = null;
       return;
     }
 

package/lib/util/manifest_parser_utils.js

@@ -185,8 +185,7 @@ shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_ = [
   /^mp4a/,
   /^[ae]c-3$/,
   /^ac-4$/,
-  /^dts[cx]$/, // DTS Surround Sound
-  /^[du]dts$/, // DTS Surround Sound
+  /^dts[cex]$/, // DTS Digital Surround (dtsc), DTS Express (dtse), DTS:X (dtsx)
 ];
 
 

package/lib/util/mime_utils.js

@@ -193,6 +193,17 @@ shaka.util.MimeUtils = class {
     return value;
   }
 
+  /**
+   * Checks if the given MIME type is HLS MIME type.
+   *
+   * @param {string} mimeType
+   * @return {boolean}
+   */
+  static isHlsType(mimeType) {
+    return mimeType === 'application/x-mpegurl' ||
+        mimeType === 'application/vnd.apple.mpegurl';
+  }
+
   /**
    * Get the base and profile of a codec string. Where [0] will be the codec
    * base and [1] will be the profile.

package/lib/util/periods.js

@@ -671,11 +671,11 @@ shaka.util.PeriodCombiner = class {
     // Also checks if the segmentIndex is still valid after the async
     // operations, to make sure we stop if the active stream has changed.
     if (outputStream.segmentIndex instanceof shaka.media.MetaSegmentIndex) {
-      for (let i = 0; i < streams.length; i++) {
+      for (let i = firstNewPeriodIndex; i < streams.length; i++) {
         const match = streams[i];
-        if (match.segmentIndex && i >= firstNewPeriodIndex) {
-          goog.asserts.assert(match.segmentIndex,
-              'stream should have a segmentIndex.');
+        goog.asserts.assert(match.segmentIndex,
+            'stream should have a segmentIndex.');
+        if (match.segmentIndex) {
           outputStream.segmentIndex.appendSegmentIndex(match.segmentIndex);
         }
       }
@@ -728,7 +728,7 @@ shaka.util.PeriodCombiner = class {
       // in advance.  concat() will add them to the output's MetaSegmentIndex.
     }
 
-    if (!outputStream.matchedStreams) {
+    if (!outputStream.matchedStreams || !outputStream.matchedStreams.length) {
       // This is not a stream we can build output from, but it may become part
       // of another output based on another period's stream.
       return null;

package/lib/util/stream_utils.js

@@ -830,7 +830,7 @@ shaka.util.StreamUtils = class {
       const video = variant.video;
       if (audio && currentVariant && currentVariant.audio) {
         if (!StreamUtils.areStreamsCompatible_(audio, currentVariant.audio)) {
-          shaka.log.debug('Droping variant - not compatible with active audio',
+          shaka.log.debug('Dropping variant - not compatible with active audio',
               'active audio',
               StreamUtils.getStreamSummaryString_(currentVariant.audio),
               'variant.audio',
@@ -841,7 +841,7 @@ shaka.util.StreamUtils = class {
 
       if (video && currentVariant && currentVariant.video) {
         if (!StreamUtils.areStreamsCompatible_(video, currentVariant.video)) {
-          shaka.log.debug('Droping variant - not compatible with active video',
+          shaka.log.debug('Dropping variant - not compatible with active video',
               'active video',
               StreamUtils.getStreamSummaryString_(currentVariant.video),
               'variant.video',

package/maintained-branches.md

@@ -2,10 +2,9 @@
 
 We are currently maintaining the following branches of Shaka Player:
 
- - v4.3 (latest)
+ - v4.3 (latest, also in use by the Cast Application Framework)
  - v4.2 (previous)
- - v3.3 (LTS until April 30, 2023)
- - v3.2 (in use by the Cast Application Framework)
+ - No active LTS branches at this time
 
 Other branches are no longer receiving bug fixes, and we recommend you upgrade
 to a maintained branch.  For details on upgrading, please see our

package/package.json

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

package/test/dash/dash_parser_live_unit.js

@@ -194,7 +194,8 @@ describe('DashParser Live', () => {
           template, {updateTime: updateTime, contents: basicLines.join('\n')});
 
       fakeNetEngine.setResponseText('dummy://foo', text);
-      Date.now = () => 0;
+      const baseTime = new Date(2015, 11, 30);
+      Date.now = () => baseTime.getTime();
       const manifest = await parser.start('dummy://foo', playerInterface);
 
       expect(manifest).toBeTruthy();
@@ -211,7 +212,7 @@ describe('DashParser Live', () => {
       // seconds long in all of these cases.  So 11 seconds after the
       // manifest was parsed, the first segment should have fallen out of
       // the availability window.
-      Date.now = () => 11 * 1000;
+      Date.now = () => baseTime.getTime() + (11 * 1000);
       await updateManifest();
       // The first reference should have been evicted.
       expect(stream.segmentIndex.find(0)).toBe(firstPosition + 1);

package/test/hls/hls_parser_unit.js

@@ -987,6 +987,118 @@ describe('HlsParser', () => {
     await testHlsParser(master, media, manifest);
   });
 
+  it('parses discontinuity tags', async () => {
+    const master = [
+      '#EXTM3U\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=2000000,CODECS="avc1"\n',
+      'video\n',
+    ].join('');
+
+    const media = [
+      '#EXTM3U\n',
+      '#EXT-X-VERSION:3\n',
+      '#EXT-X-TARGETDURATION:5\n',
+      '#EXT-X-MEDIA-SEQUENCE:0\n',
+      '#EXTINF:3,\n',
+      'clip0-video-0.ts\n',
+      '#EXTINF:1,\n',
+      'clip0-video-1.ts\n',
+      '#EXT-X-DISCONTINUITY\n',
+      '#EXTINF:2,\n',
+      'clip1-video-1.ts\n',
+      '#EXTINF:3,\n',
+      'clip1-video-2.ts\n',
+      '#EXT-X-DISCONTINUITY\n',
+      '#EXTINF:1,\n',
+      'media-clip2-video-0.ts\n',
+      '#EXTINF:1,\n',
+      'media-clip2-video-1.ts\n',
+      '#EXT-X-DISCONTINUITY\n',
+      '#EXTINF:4,\n',
+      'media-clip3-video-1.ts\n',
+      '#EXT-X-ENDLIST\n',
+    ].join('');
+
+    fakeNetEngine
+        .setResponseText('test:/master', master)
+        .setResponseText('test:/video', media);
+
+    const manifest = await parser.start('test:/master', playerInterface);
+    await manifest.variants[0].video.createSegmentIndex();
+
+    const segmentIndex = manifest.variants[0].video.segmentIndex;
+    const references = [];
+
+    for (let i = 0; i < 7; i++) {
+      references.push(segmentIndex.get(i));
+    }
+
+    expect(references[0].discontinuitySequence).toBe(0);
+    expect(references[1].discontinuitySequence).toBe(0);
+    expect(references[2].discontinuitySequence).toBe(1);
+    expect(references[3].discontinuitySequence).toBe(1);
+    expect(references[4].discontinuitySequence).toBe(2);
+    expect(references[5].discontinuitySequence).toBe(2);
+    expect(references[6].discontinuitySequence).toBe(3);
+  });
+
+  it('sets reference timetampOffset based on discontinuity start time',
+      async () => {
+        const master = [
+          '#EXTM3U\n',
+          '#EXT-X-STREAM-INF:BANDWIDTH=2000000,CODECS="avc1"\n',
+          'video\n',
+        ].join('');
+
+        const media = [
+          '#EXTM3U\n',
+          '#EXT-X-VERSION:3\n',
+          '#EXT-X-TARGETDURATION:5\n',
+          '#EXT-X-MEDIA-SEQUENCE:0\n',
+          '#EXTINF:3,\n',
+          'clip0-video-0.ts\n',
+          '#EXTINF:1,\n',
+          'clip0-video-1.ts\n',
+          '#EXT-X-DISCONTINUITY\n',
+          '#EXTINF:2,\n',
+          'clip1-video-1.ts\n',
+          '#EXTINF:3,\n',
+          'clip1-video-2.ts\n',
+          '#EXT-X-DISCONTINUITY\n',
+          '#EXTINF:1,\n',
+          'media-clip2-video-0.ts\n',
+          '#EXTINF:1,\n',
+          'media-clip2-video-1.ts\n',
+          '#EXT-X-DISCONTINUITY\n',
+          '#EXTINF:4,\n',
+          'media-clip3-video-1.ts\n',
+          '#EXT-X-ENDLIST\n',
+        ].join('');
+
+        fakeNetEngine
+            .setResponseText('test:/master', master)
+            .setResponseText('test:/video', media);
+
+        const manifest = await parser.start('test:/master', playerInterface);
+        await manifest.variants[0].video.createSegmentIndex();
+
+        const segmentIndex = manifest.variants[0].video.segmentIndex;
+        const references = [];
+
+        for (let i = 0; i < 7; i++) {
+          references.push(segmentIndex.get(i));
+        }
+
+        expect(references[0].timestampOffset).toBe(0);
+        expect(references[1].timestampOffset).toBe(0);
+        expect(references[2].timestampOffset).toBe(4);
+        expect(references[3].timestampOffset).toBe(4);
+        expect(references[4].timestampOffset).toBe(9);
+        expect(references[5].timestampOffset).toBe(9);
+        expect(references[6].timestampOffset).toBe(11);
+      },
+  );
+
   it('parses characteristics from audio tags', async () => {
     const master = [
       '#EXTM3U\n',
@@ -2132,6 +2244,50 @@ describe('HlsParser', () => {
     expect(actual).toEqual(manifest);
   });
 
+  it('parses manifest with MP4+WEBVTT streams', async () => {
+    const master = [
+      '#EXTM3U\n',
+      '#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="sub1",LANGUAGE="eng",',
+      'CODECS="wvtt",URI="text"\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1",',
+      'RESOLUTION=960x540,FRAME-RATE=60,SUBTITLES="sub1"\n',
+      'video\n',
+    ].join('');
+
+    const media = [
+      '#EXTM3U\n',
+      '#EXT-X-PLAYLIST-TYPE:VOD\n',
+      '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+      '#EXTINF:5,\n',
+      '#EXT-X-BYTERANGE:121090@616\n',
+      'main.mp4',
+    ].join('');
+
+    const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+      manifest.anyTimeline();
+      manifest.addPartialVariant((variant) => {
+        variant.addPartialStream(ContentType.VIDEO);
+      });
+      manifest.addPartialTextStream((stream) => {
+        stream.language = 'en';
+        stream.mime('application/mp4', 'wvtt');
+      });
+      manifest.sequenceMode = true;
+    });
+
+    fakeNetEngine
+        .setResponseText('test:/master', master)
+        .setResponseText('test:/audio', media)
+        .setResponseText('test:/video', media)
+        .setResponseText('test:/text', media)
+        .setResponseValue('test:/init.mp4', initSegmentData)
+        .setResponseValue('test:/main.mp4', segmentData);
+
+    const actual = await parser.start('test:/master', playerInterface);
+    await loadAllStreamsFor(actual);
+    expect(actual).toEqual(manifest);
+  });
+
   it('detects VTT streams by codec', async () => {
     const master = [
       '#EXTM3U\n',