shaka-player 4.3.4 → 4.3.6

package/lib/hls/hls_parser.js

@@ -311,7 +311,10 @@ shaka.hls.HlsParser = class {
       const PresentationType = shaka.hls.HlsParser.PresentationType_;
       this.setPresentationType_(PresentationType.VOD);
 
-      const maxTimestamps = streamInfos.map((s) => s.maxTimestamp);
+      // The duration is the minimum of the end times of all active streams.
+      // Non-active streams are not guaranteed to have useful maxTimestamp
+      // values, due to the lazy-loading system, so they are ignored.
+      const maxTimestamps = activeStreamInfos.map((s) => s.maxTimestamp);
       // The duration is the minimum of the end times of all streams.
       this.presentationTimeline_.setDuration(Math.min(...maxTimestamps));
       this.playerInterface_.updateDuration();
@@ -1455,9 +1458,9 @@ shaka.hls.HlsParser = class {
     let codecs = '';
     /** @type {string} */
     const type = this.getType_(tag);
-    // Text does not require a codec.
-    if (type != shaka.util.ManifestParserUtils.ContentType.TEXT && groupId &&
-        this.groupIdToCodecsMap_.has(groupId)) {
+    if (type == shaka.util.ManifestParserUtils.ContentType.TEXT) {
+      codecs = tag.getAttributeValue('CODECS') || '';
+    } else if (groupId && this.groupIdToCodecsMap_.has(groupId)) {
       codecs = this.groupIdToCodecsMap_.get(groupId);
     }
 
@@ -1733,6 +1736,13 @@ shaka.hls.HlsParser = class {
         }
       }
 
+      if (type == ContentType.TEXT) {
+        const firstSegment = realStream.segmentIndex.get(0);
+        if (firstSegment && firstSegment.initSegmentReference) {
+          stream.mimeType = 'application/mp4';
+        }
+      }
+
       // Add finishing touches to the stream that can only be done once we have
       // more full context on the media as a whole.
       if (this.hasEnoughInfoToFinalizeStreams_()) {
@@ -2368,13 +2378,15 @@ shaka.hls.HlsParser = class {
    * @param {!Map.<string, string>} variables
    * @param {string} absoluteMediaPlaylistUri
    * @param {string} type
+   * @param {number} timestampOffset
    * @param {shaka.extern.HlsAes128Key=} hlsAes128Key
    * @return {shaka.media.SegmentReference}
    * @private
    */
   createSegmentReference_(
       initSegmentReference, previousReference, hlsSegment, startTime,
-      variables, absoluteMediaPlaylistUri, type, hlsAes128Key) {
+      variables, absoluteMediaPlaylistUri, type, timestampOffset,
+      hlsAes128Key) {
     const tags = hlsSegment.tags;
     const absoluteSegmentUri = this.variableSubstitution_(
         hlsSegment.absoluteUri, variables);
@@ -2544,7 +2556,7 @@ shaka.hls.HlsParser = class {
         startByte,
         endByte,
         initSegmentReference,
-        /* timestampOffset= */ 0, // This value is ignored in sequence mode.
+        timestampOffset, // This value is ignored in sequence mode.
         /* appendWindowStart= */ 0,
         /* appendWindowEnd= */ Infinity,
         partialSegmentRefs,
@@ -2629,6 +2641,7 @@ shaka.hls.HlsParser = class {
     const references = [];
 
     let previousReference = null;
+    let lastDiscontinuityStartTime = firstStartTime;
 
     for (let i = 0; i < hlsSegments.length; i++) {
       const item = hlsSegments[i];
@@ -2640,6 +2653,7 @@ shaka.hls.HlsParser = class {
           item.tags, 'EXT-X-DISCONTINUITY');
       if (discontinuityTag) {
         discontinuitySequence++;
+        lastDiscontinuityStartTime = startTime;
       }
 
       // Apply new AES-128 tags as you see them, keeping a running total.
@@ -2678,6 +2692,7 @@ shaka.hls.HlsParser = class {
           variables,
           playlist.absoluteUri,
           type,
+          lastDiscontinuityStartTime,
           hlsAes128Key);
       previousReference = reference;
 
@@ -3317,6 +3332,7 @@ shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_ = {
   'cmfa': 'audio/mp4',
   // MPEG2-TS also uses video/ for audio: https://bit.ly/TsMse
   'ts': 'video/mp2t',
+  'tsa': 'video/mp2t',
 };
 
 
@@ -3333,6 +3349,7 @@ shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_ = {
   'm4f': 'video/mp4',
   'cmfv': 'video/mp4',
   'ts': 'video/mp2t',
+  'tsv': 'video/mp2t',
 };
 
 

package/lib/media/drm_engine.js

@@ -480,8 +480,10 @@ shaka.media.DrmEngine = class {
           () => this.closeOpenSessions_());
     }
 
-    const manifestInitData = this.currentDrmInfo_.initData.find(
-        (initDataOverride) => initDataOverride.initData.length > 0);
+    const manifestInitData = this.currentDrmInfo_ ?
+      this.currentDrmInfo_.initData.find(
+          (initDataOverride) => initDataOverride.initData.length > 0,
+      ) : null;
 
     /**
      * We can attach media keys before the playback actually begins when:

package/lib/media/media_source_engine.js

@@ -202,6 +202,9 @@ shaka.media.MediaSourceEngine = class {
       'audio/mp4; codecs="ec-3"',
       'audio/mp4; codecs="opus"',
       'audio/mp4; codecs="flac"',
+      'audio/mp4; codecs="dtsc"', // DTS Digital Surround
+      'audio/mp4; codecs="dtse"', // DTS Express
+      'audio/mp4; codecs="dtsx"', // DTS:X
       // WebM types
       'video/webm; codecs="vp8"',
       'video/webm; codecs="vp9"',
@@ -375,7 +378,22 @@ shaka.media.MediaSourceEngine = class {
               shaka.media.Transmuxer.convertCodecs(contentType, mimeType);
         }
         const type = mimeType + this.config_.sourceBufferExtraFeatures;
-        const sourceBuffer = this.mediaSource_.addSourceBuffer(type);
+
+        this.destroyer_.ensureNotDestroyed();
+
+        let sourceBuffer;
+
+        try {
+          sourceBuffer = this.mediaSource_.addSourceBuffer(type);
+        } catch (exception) {
+          throw new shaka.util.Error(
+              shaka.util.Error.Severity.CRITICAL,
+              shaka.util.Error.Category.MEDIA,
+              shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
+              exception,
+              'The mediaSource_ status was' + this.mediaSource_.readyState +
+              'expected \'open\'');
+        }
 
         this.eventManager_.listen(
             sourceBuffer, 'error',
@@ -628,7 +646,8 @@ shaka.media.MediaSourceEngine = class {
       // For HLS CEA-608/708 CLOSED-CAPTIONS, text data is embedded in
       // the video stream, so textEngine may not have been initialized.
       if (!this.textEngine_) {
-        this.reinitText('text/vtt', this.sequenceMode_);
+        this.reinitText(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE,
+            this.sequenceMode_);
       }
       // This doesn't work for native TS support (ex. Edge/Chromecast),
       // since no transmuxing is needed for native TS.
@@ -647,7 +666,8 @@ shaka.media.MediaSourceEngine = class {
       data = transmuxedData.data;
     } else if (hasClosedCaptions && contentType == ContentType.VIDEO) {
       if (!this.textEngine_) {
-        this.reinitText('text/vtt', this.sequenceMode_);
+        this.reinitText(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE,
+            this.sequenceMode_);
       }
       if (!this.captionParser_) {
         this.captionParser_ = this.getCaptionParser(mimeType);
@@ -937,7 +957,6 @@ shaka.media.MediaSourceEngine = class {
 
   /**
    * Adjust timestamp offset to maintain AV sync across discontinuities.
-   * Only used in sequence mode.
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {number} timestampOffset
@@ -946,9 +965,6 @@ shaka.media.MediaSourceEngine = class {
   async resync(contentType, timestampOffset) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    goog.asserts.assert(this.sequenceMode_,
-        'resync only used with sequence mode!');
-
     if (contentType == ContentType.TEXT) {
       // This operation is for audio and video only.
       return;
@@ -978,8 +994,10 @@ shaka.media.MediaSourceEngine = class {
   async endOfStream(reason) {
     await this.enqueueBlockingOperation_(() => {
       // If endOfStream() has already been called on the media source,
-      // don't call it again.
-      if (this.ended()) {
+      // don't call it again. Also do not call if readyState is
+      // 'closed' (not attached to video element) since it is not a
+      // valid operation.
+      if (this.ended() || this.mediaSource_.readyState === 'closed') {
         return;
       }
       // Tizen won't let us pass undefined, but it will let us omit the

package/lib/media/presentation_timeline.js

@@ -236,7 +236,16 @@ shaka.media.PresentationTimeline = class {
 
     let firstReferenceStartTime = references[0].startTime;
     let lastReferenceEndTime = references[0].endTime;
+
+    // Date.now() is in milliseconds, from which we compute "now" in seconds.
+    const now = (Date.now() + this.clockOffset_) / 1000.0;
+
     for (const reference of references) {
+      // Exclude segments that are in the "future".
+      if (now < reference.startTime) {
+        continue;
+      }
+
       firstReferenceStartTime = Math.min(
           firstReferenceStartTime, reference.startTime);
       lastReferenceEndTime = Math.max(lastReferenceEndTime, reference.endTime);
@@ -251,8 +260,6 @@ shaka.media.PresentationTimeline = class {
         !this.startTimeLocked_) {
       // Since we have explicit segment end times, calculate a presentation
       // start based on them.  This start time accounts for drift.
-      // Date.now() is in milliseconds, from which we compute "now" in seconds.
-      const now = (Date.now() + this.clockOffset_) / 1000.0;
       this.presentationStartTime_ =
           now - this.maxSegmentEndTime_ - this.maxSegmentDuration_;
     }

package/lib/media/segment_index.js

@@ -363,6 +363,8 @@ shaka.media.SegmentIndex = class {
             lastReference.status,
             lastReference.hlsAes128Key,
         );
+    this.references[this.references.length - 1].discontinuitySequence =
+        lastReference.discontinuitySequence;
   }
 
 

package/lib/media/segment_reference.js

@@ -144,8 +144,9 @@ shaka.media.SegmentReference = class {
    *   minus the first segment's tfdt box's 'baseMediaDecodeTime' field (after
    *   it has been converted to seconds).
    *   <br>
-   *   For HLS, this value should be 0 to keep the presentation time at the most
-   *   recent discontinuity minus the corresponding media time.
+   *   For HLS, this value should be the start time of the most recent
+   *   discontinuity, or 0 if there is no preceding discontinuity. Only used
+   *   in segments mode.
    * @param {number} appendWindowStart
    *   The start of the append window for this reference, relative to the
    *   presentation.  Any content from before this time will be removed by

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/media/transmuxer.js

@@ -35,9 +35,7 @@ shaka.media.Transmuxer = class {
     this.muxjs_ = shaka.dependencies.muxjs();
 
     /** @private {muxjs.mp4.Transmuxer} */
-    this.muxTransmuxer_ = new this.muxjs_.mp4.Transmuxer({
-      'keepOriginalTimestamps': true,
-    });
+    this.muxTransmuxer_ = null;
 
     /** @private {shaka.util.PublicPromise} */
     this.transmuxPromise_ = null;
@@ -51,16 +49,22 @@ shaka.media.Transmuxer = class {
     /** @private {boolean} */
     this.isTransmuxing_ = false;
 
-    this.muxTransmuxer_.on('data', (segment) => this.onTransmuxed_(segment));
-
-    this.muxTransmuxer_.on('done', () => this.onTransmuxDone_());
+    if (this.muxjs_) {
+      this.muxTransmuxer_ = new this.muxjs_.mp4.Transmuxer({
+        'keepOriginalTimestamps': true,
+      });
+      this.muxTransmuxer_.on('data', (segment) => this.onTransmuxed_(segment));
+      this.muxTransmuxer_.on('done', () => this.onTransmuxDone_());
+    }
   }
 
   /**
    * @override
    */
   destroy() {
-    this.muxTransmuxer_.dispose();
+    if (this.muxTransmuxer_) {
+      this.muxTransmuxer_.dispose();
+    }
     this.muxTransmuxer_ = null;
     return Promise.resolve();
   }
@@ -216,6 +220,8 @@ shaka.media.Transmuxer = class {
    *                     captions: !Array.<!muxjs.mp4.ClosedCaption>}>}
    */
   transmux(data) {
+    goog.asserts.assert(this.muxTransmuxer_,
+        'mux.js should be available.');
     goog.asserts.assert(!this.isTransmuxing_,
         'No transmuxing should be in progress.');
     this.isTransmuxing_ = true;

package/lib/media/video_wrapper.js

@@ -135,15 +135,15 @@ shaka.media.VideoWrapper = class {
     // calling |Player.load|, meaning that |currentTime| is more meaningful than
     // |startTime|.
     //
-    // Seeking to the current time is a work around for Issue 1298. If we don't
-    // do this, the video may get stuck and not play.
+    // Seeking to the current time is a work around for Issue 1298 and 4888.
+    // If we don't do this, the video may get stuck and not play.
     //
     // TODO: Need further investigation why it happens. Before and after
     // setting the current time, video.readyState is 1, video.paused is true,
     // and video.buffered's TimeRanges length is 0.
     // See: https://github.com/shaka-project/shaka-player/issues/1298
     this.mover_.moveTo(
-        this.video_.currentTime == 0 ?
+        (!this.video_.currentTime || this.video_.currentTime == 0) ?
         startTime :
         this.video_.currentTime);
   }

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/offline/indexeddb/storage_mechanism.js

@@ -67,7 +67,7 @@ shaka.offline.indexeddb.StorageMechanism = class {
           shaka.util.Error.Category.STORAGE,
           shaka.util.Error.Code.INDEXED_DB_INIT_TIMED_OUT));
     });
-    timeOutTimer.tickAfter(2);
+    timeOutTimer.tickAfter(5);
 
     const open = window.indexedDB.open(name, version);
     open.onsuccess = (event) => {

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;
       }
 
@@ -2584,6 +2590,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               // goes wrong.
               new shaka.util.Timer(resolve).tickAfter(1);
             });
+          } else if (textTracks.length > 0) {
+            this.isTextVisible_ = true;
           }
 
           // If we have moved on to another piece of content while waiting for
@@ -4274,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);
+      }
     }
   }
 
@@ -6984,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.4-uncompiled';
+shaka.Player.version = 'v4.3.6-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.