shaka-player 4.3.12 → 4.3.14

package/lib/media/streaming_engine.js

@@ -6,7 +6,6 @@
 
 /**
  * @fileoverview
- * @suppress {missingRequire} TODO(b/152540451): this shouldn't be needed
  */
 
 goog.provide('shaka.media.StreamingEngine');
@@ -19,6 +18,8 @@ goog.require('shaka.media.SegmentIterator');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.net.Backoff');
 goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.CmcdManager');
 goog.require('shaka.util.DelayedTick');
 goog.require('shaka.util.Destroyer');
 goog.require('shaka.util.Error');
@@ -27,6 +28,7 @@ goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
+goog.require('shaka.util.Mp4BoxParsers');
 goog.require('shaka.util.Mp4Parser');
 goog.require('shaka.util.Networking');
 
@@ -1285,6 +1287,7 @@ shaka.media.StreamingEngine = class {
         let remaining = new Uint8Array(0);
         let processingResult = false;
         let callbackCalled = false;
+        let streamDataCallbackError;
         const streamDataCallback = async (data) => {
           if (processingResult) {
             // If the fallback result processing was triggered, don't also
@@ -1297,35 +1300,44 @@ shaka.media.StreamingEngine = class {
           if (this.fatalError_) {
             return;
           }
-          // Append the data with complete boxes.
-          // Every time streamDataCallback gets called, append the new data to
-          // the remaining data.
-          // Find the last fully completed Mdat box, and slice the data into two
-          // parts: the first part with completed Mdat boxes, and the second
-          // part with an incomplete box.
-          // Append the first part, and save the second part as remaining data,
-          // and handle it with the next streamDataCallback call.
-          remaining = this.concatArray_(remaining, data);
-          let sawMDAT = false;
-          let offset = 0;
-          new shaka.util.Mp4Parser()
-              .box('mdat', (box) => {
-                offset = box.size + box.start;
-                sawMDAT = true;
-              })
-              .parse(remaining, /* partialOkay= */ false,
+          try {
+            // Append the data with complete boxes.
+            // Every time streamDataCallback gets called, append the new data
+            // to the remaining data.
+            // Find the last fully completed Mdat box, and slice the data into
+            // two parts: the first part with completed Mdat boxes, and the
+            // second part with an incomplete box.
+            // Append the first part, and save the second part as remaining
+            // data, and handle it with the next streamDataCallback call.
+            remaining = this.concatArray_(remaining, data);
+            let sawMDAT = false;
+            let offset = 0;
+            new shaka.util.Mp4Parser()
+                .box('mdat', (box) => {
+                  offset = box.size + box.start;
+                  sawMDAT = true;
+                })
+                .parse(remaining, /* partialOkay= */ false,
+                    /* isChunkedData= */ true);
+            if (sawMDAT) {
+              const dataToAppend = remaining.subarray(0, offset);
+              remaining = remaining.subarray(offset);
+              await this.append_(
+                  mediaState, presentationTime, stream, reference, dataToAppend,
                   /* isChunkedData= */ true);
-          if (sawMDAT) {
-            const dataToAppend = remaining.subarray(0, offset);
-            remaining = remaining.subarray(offset);
-            await this.append_(
-                mediaState, presentationTime, stream, reference, dataToAppend,
-                /* isChunkedData= */ true);
+            }
+          } catch (error) {
+            streamDataCallbackError = error;
           }
         };
 
         const result =
             await this.fetch_(mediaState, reference, streamDataCallback);
+
+        if (streamDataCallbackError) {
+          throw streamDataCallbackError;
+        }
+
         if (!callbackCalled) {
           // In some environments, we might be forced to use network plugins
           // that don't support streamDataCallback. In those cases, as a
@@ -1357,16 +1369,11 @@ shaka.media.StreamingEngine = class {
             'ReadableStream is not supported by the browser.');
         }
         const fetchSegment = this.fetch_(mediaState, reference);
-        let result = await fetchSegment;
+        const result = await fetchSegment;
         this.destroyer_.ensureNotDestroyed();
         if (this.fatalError_) {
           return;
         }
-        if (reference.hlsAes128Key) {
-          goog.asserts.assert(iter, 'mediaState.segmentIterator should exist');
-          result = await this.aes128Decrypt_(result, reference, iter);
-        }
-        this.destroyer_.ensureNotDestroyed();
 
         // If the text stream gets switched between fetch_() and append_(), the
         // new text parser is initialized, but the new init segment is not
@@ -1450,13 +1457,13 @@ shaka.media.StreamingEngine = class {
 
   /**
    * @param {!BufferSource} rawResult
-   * @param {!shaka.media.SegmentReference} reference
+   * @param {shaka.extern.HlsAes128Key} aes128Key
    * @param {!shaka.media.SegmentIterator} iter
    * @return {!Promise.<!BufferSource>} finalResult
    * @private
    */
-  async aes128Decrypt_(rawResult, reference, iter) {
-    const key = reference.hlsAes128Key;
+  async aes128Decrypt_(rawResult, aes128Key, iter) {
+    const key = aes128Key;
     if (!key.cryptoKey) {
       goog.asserts.assert(key.fetchKey, 'If AES-128 cryptoKey was not ' +
           'preloaded, fetchKey function should be provided');
@@ -1693,10 +1700,10 @@ shaka.media.StreamingEngine = class {
       }
     }
 
-    const lastDiscontinuitySequence =
-        mediaState.lastSegmentReference ?
-            mediaState.lastSegmentReference.discontinuitySequence : null;
     if (this.manifest_.sequenceMode) {
+      const lastDiscontinuitySequence =
+          mediaState.lastSegmentReference ?
+              mediaState.lastSegmentReference.discontinuitySequence : null;
       // 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.
@@ -1706,18 +1713,6 @@ shaka.media.StreamingEngine = class {
         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);
@@ -2021,8 +2016,8 @@ shaka.media.StreamingEngine = class {
     const bufferedBehind = presentationTime - startTime;
 
     const overflow = bufferedBehind - bufferBehind;
-    // See: https://github.com/shaka-project/shaka-player/issues/2982
-    if (overflow <= 0.01) {
+    // See: https://github.com/shaka-project/shaka-player/issues/6240
+    if (overflow <= 1) {
       shaka.log.v2(logPrefix,
           'buffer behind okay:',
           'presentationTime=' + presentationTime,
@@ -2073,7 +2068,6 @@ shaka.media.StreamingEngine = class {
    *
    * @return {!Promise.<BufferSource>}
    * @private
-   * @suppress {strictMissingProperties}
    */
   async fetch_(mediaState, reference, streamDataCallback) {
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
@@ -2088,12 +2082,17 @@ shaka.media.StreamingEngine = class {
     shaka.log.v2('fetching: reference=', reference);
 
     const stream = mediaState.stream;
+    const isInit = reference instanceof shaka.media.InitSegmentReference;
+    const mediaReference =
+    /** @type {!shaka.media.SegmentReference} */(reference);
+    const duration = isInit ? 0 :
+        mediaReference.endTime - mediaReference.startTime;
     this.playerInterface_.modifySegmentRequest(
         request,
         {
           type: stream.type,
-          init: reference instanceof shaka.media.InitSegmentReference,
-          duration: reference.endTime - reference.startTime,
+          init: isInit,
+          duration,
           mimeType: stream.mimeType,
           codecs: stream.codecs,
           bandwidth: stream.bandwidth,
@@ -2104,7 +2103,18 @@ shaka.media.StreamingEngine = class {
     mediaState.operation = op;
     const response = await op.promise;
     mediaState.operation = null;
-    return response.data;
+
+    let result = response.data;
+    if (reference.hlsAes128Key) {
+      let iter = mediaState.segmentIterator;
+      const time = isInit ? null : mediaReference.startTime;
+      if (!iter && time != null) {
+        iter = mediaState.stream.segmentIndex.getIteratorForTime(time);
+      }
+      goog.asserts.assert(iter, 'mediaState.segmentIterator should exist');
+      result = await this.aes128Decrypt_(result, reference.hlsAes128Key, iter);
+    }
+    return result;
   }
 
 

package/lib/media/transmuxer.js

@@ -208,7 +208,7 @@ shaka.media.Transmuxer = class {
    * Returns the original mimetype of the transmuxer.
    * @return {string}
    */
-  getOrginalMimeType() {
+  getOriginalMimeType() {
     return this.originalMimeType_;
   }
 

package/lib/media/video_wrapper.js

@@ -175,8 +175,8 @@ shaka.media.VideoWrapper = class {
 
 /**
  * A class used to move the playhead away from its current time.  Sometimes,
- * Edge ignores re-seeks. After changing the current time, check every 100ms,
- * retrying if the change was not accepted.
+ * legacy Edge ignores re-seeks. After changing the current time, check every
+ * 100ms, retrying if the change was not accepted.
  *
  * Delay stats over 100 runs of a re-seeking integration test:
  *   Edge   -   0ms -   2%
@@ -186,7 +186,8 @@ shaka.media.VideoWrapper = class {
  *   Edge   - 400ms -   2%
  *   Chrome -   0ms - 100%
  *
- * TODO: File a bug on Edge about this.
+ * Unfortunately, legacy Edge is not receiving updates anymore, but it still
+ * must be supported as it is used for web browsers on XBox.
  *
  * @implements {shaka.util.IReleasable}
  * @final

package/lib/offline/offline_manifest_parser.js

@@ -112,6 +112,11 @@ shaka.offline.OfflineManifestParser = class {
       await muxer.destroy();
     }
   }
+
+  /** @override */
+  onInitialVariantChosen(variant) {
+    // No-op
+  }
 };
 
 

package/lib/offline/session_deleter.js

@@ -71,14 +71,6 @@ shaka.offline.SessionDeleter = class {
       return [];
     }
 
-    try {
-      await drmEngine.setServerCertificate();
-    } catch (e) {
-      shaka.log.warning('Error setting server certificate', e);
-      await drmEngine.destroy();
-      return [];
-    }
-
     /** @type {!Array.<string>} */
     const sessionIds = [];
     await Promise.all(bucket.sessionIds.map(async (sessionId) => {

package/lib/offline/storage.js

@@ -396,6 +396,10 @@ shaka.offline.Storage = class {
           downloader, config, activeHandle.cell, manifest, drmEngine);
       this.ensureNotDestroyed_();
 
+      this.setManifestDrmFields_(manifest, manifestDB, drmEngine, config);
+      await activeHandle.cell.updateManifest(manifestId, manifestDB);
+      this.ensureNotDestroyed_();
+
       const offlineUri = shaka.offline.OfflineUri.manifest(
           activeHandle.path.mechanism, activeHandle.path.cell, manifestId);
 
@@ -1231,7 +1235,6 @@ shaka.offline.Storage = class {
     drmEngine.configure(config.drm);
     await drmEngine.initForStorage(
         manifest.variants, config.offline.usePersistentLicense);
-    await drmEngine.setServerCertificate();
     await drmEngine.createOrLoad();
 
     return drmEngine;

package/lib/player.js

@@ -479,6 +479,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
      */
     this.loadEventManager_ = new shaka.util.EventManager();
 
+    /**
+     * For listeners scoped to the lifetime of the loaded content.
+     * @private {shaka.util.EventManager}
+     */
+    this.trickPlayEventManager_ = new shaka.util.EventManager();
+
     /** @private {shaka.net.NetworkingEngine} */
     this.networkingEngine_ = null;
 
@@ -897,6 +903,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.loadEventManager_.release();
       this.loadEventManager_ = null;
     }
+    if (this.trickPlayEventManager_) {
+      this.trickPlayEventManager_.release();
+      this.trickPlayEventManager_ = null;
+    }
 
     this.abrManagerFactory_ = null;
     this.config_ = null;
@@ -1555,6 +1565,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // be if there was an error and we, by chance, did not have a media element.
     if (has.mediaElement) {
       this.loadEventManager_.removeAll();
+      this.trickPlayEventManager_.removeAll();
     }
 
     // Stop the variant checker timer
@@ -2012,8 +2023,17 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     this.drmEngine_.configure(this.config_.drm);
 
+    const tracksChanged = shaka.util.StreamUtils.applyRestrictions(
+        this.manifest_.variants, this.config_.restrictions, this.maxHwRes_);
+    if (tracksChanged && this.streamingEngine_) {
+      this.onTracksChanged_();
+    }
+
+    const playableVariants = shaka.util.StreamUtils.getPlayableVariants(
+        this.manifest_.variants);
+
     await this.drmEngine_.initForPlayback(
-        this.manifest_.variants,
+        playableVariants,
         this.manifest_.offlineSessionIds);
 
     await this.drmEngine_.attach(has.mediaElement);
@@ -2192,6 +2212,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       await Promise.all(createSegmentIndexPromises);
     }
 
+    if (this.parser_ && this.parser_.onInitialVariantChosen) {
+      this.parser_.onInitialVariantChosen(toLazyLoad);
+    }
+
     shaka.Player.applyPlayRange_(this.manifest_.presentationTimeline,
         this.config_.playRangeStart,
         this.config_.playRangeEnd);
@@ -3705,6 +3729,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       shaka.log.alwaysWarn('A trick play rate of 0 is unsupported!');
       return;
     }
+    this.trickPlayEventManager_.removeAll();
 
     if (this.video_.paused) {
       // Our fast forward is implemented with playbackRate and needs the video
@@ -3718,6 +3743,22 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.abrManager_.playbackRateChanged(rate);
       this.streamingEngine_.setTrickPlay(Math.abs(rate) > 1);
     }
+    if (this.isLive()) {
+      this.trickPlayEventManager_.listen(this.video_, 'timeupdate', () => {
+        const currentTime = this.video_.currentTime;
+        const seekRange = this.seekRange();
+        const safeSeekOffset = this.config_.streaming.safeSeekOffset;
+        if (rate > 0) {
+          if (currentTime >= seekRange.end) {
+            this.cancelTrickPlay();
+          }
+        } else {
+          if (currentTime <= (seekRange.start + safeSeekOffset)) {
+            this.cancelTrickPlay();
+          }
+        }
+      });
+    }
   }
 
   /**
@@ -3737,6 +3778,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.abrManager_.playbackRateChanged(defaultPlaybackRate);
       this.streamingEngine_.setTrickPlay(false);
     }
+    this.trickPlayEventManager_.removeAll();
   }
 
   /**
@@ -4635,7 +4677,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
       if (this.isLive()) {
         const now = this.getPresentationStartTimeAsDate().valueOf() +
-            this.seekRange().end * 1000;
+            element.currentTime * 1000;
         const latency = (Date.now() - now) / 1000;
         this.stats_.setLiveLatency(latency);
       }
@@ -4689,6 +4731,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           shaka.util.Error.Code.CONTENT_NOT_LOADED);
     }
 
+    if (kind != 'subtitles' && kind != 'captions') {
+      shaka.log.alwaysWarn(
+          'Using a kind value different of `subtitles` or `captions` can ' +
+          'cause unwanted issues.');
+    }
+
     if (!mimeType) {
       mimeType = await this.getTextMimetype_(uri);
     }
@@ -4707,9 +4755,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
       await this.addSrcTrackElement_(uri, language, kind, mimeType, label || '',
           adCuePoints);
+
+      const LanguageUtils = shaka.util.LanguageUtils;
+      const languageNormalized = LanguageUtils.normalize(language);
+
       const textTracks = this.getTextTracks();
       const srcTrack = textTracks.find((t) => {
-        return t.language == language &&
+        return LanguageUtils.normalize(t.language) == languageNormalized &&
             t.label == (label || '') &&
             t.kind == kind;
       });
@@ -4871,16 +4923,22 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       vttOffset: 0,
     };
     const data = shaka.util.BufferUtils.toUint8(buffer);
-    const cues = TextParser.parseMedia(data, time);
+    const cues = TextParser.parseMedia(data, time, uri);
 
     const references = [];
     for (const cue of cues) {
-      const imageUri = shaka.util.ManifestParserUtils.resolveUris(
-          [uri], [cue.payload])[0];
+      let uris = null;
+      const getUris = () => {
+        if (uris == null) {
+          uris = shaka.util.ManifestParserUtils.resolveUris(
+              [uri], [cue.payload]);
+        }
+        return uris || [];
+      };
       const reference = new shaka.media.SegmentReference(
           cue.startTime,
           cue.endTime,
-          () => [imageUri],
+          getUris,
           /* startByte= */ 0,
           /* endByte= */ null,
           /* initSegmentReference= */ null,
@@ -4888,8 +4946,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           /* appendWindowStart= */ 0,
           /* appendWindowEnd= */ Infinity,
       );
-      if (imageUri.includes('#xywh')) {
-        const spriteInfo = imageUri.split('#xywh=')[1].split(',');
+      if (cue.payload.includes('#xywh')) {
+        const spriteInfo = cue.payload.split('#xywh=')[1].split(',');
         if (spriteInfo.length === 4) {
           reference.setThumbnailSprite({
             height: parseInt(spriteInfo[3], 10),
@@ -5129,7 +5187,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         vttOffset: 0,
       };
       const data = shaka.util.BufferUtils.toUint8(buffer);
-      const cues = obj.parseMedia(data, time);
+      const cues = obj.parseMedia(data, time, /* uri= */ null);
       return shaka.text.WebVttGenerator.convert(cues, adCuePoints);
     }
     throw new shaka.util.Error(
@@ -5248,7 +5306,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         return new shaka.text.UITextDisplayer(
             this.video_, this.videoContainer_);
       } else {
-        return new shaka.text.SimpleTextDisplayer(this.video_);
+        return new shaka.text.SimpleTextDisplayer(
+            this.video_, shaka.Player.TextTrackLabel);
       }
     };
     return config;
@@ -6263,6 +6322,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const restrictedStatuses = shaka.Player.restrictedStatuses_;
     let tracksChanged = false;
 
+    goog.asserts.assert(this.drmEngine_, 'drmEngine should be non-null here.');
+
     // Only filter tracks for keys if we have some key statuses to look at.
     if (keyIds.length) {
       for (const variant of this.manifest_.variants) {
@@ -6278,8 +6339,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
             for (const keyId of stream.keyIds) {
               const keyStatus = keyStatusMap[isGlobalStatus ? '00' : keyId];
-              variant.allowedByKeySystem = variant.allowedByKeySystem &&
-                  !!keyStatus && !restrictedStatuses.includes(keyStatus);
+              if (keyStatus || this.drmEngine_.hasManifestInitData()) {
+                variant.allowedByKeySystem = variant.allowedByKeySystem &&
+                    !!keyStatus && !restrictedStatuses.includes(keyStatus);
+              }
             }
           }
 
@@ -6291,6 +6354,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }  // if (keyIds.size)
 
     if (tracksChanged) {
+      this.onTracksChanged_();
       const variantsUpdated = this.updateAbrManagerVariants_();
       if (!variantsUpdated) {
         return;
@@ -6302,10 +6366,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       shaka.log.debug('Choosing new streams after key status changed');
       this.chooseVariantAndSwitch_();
     }
-
-    if (tracksChanged) {
-      this.onTracksChanged_();
-    }
   }
 
   /**
@@ -6971,7 +7031,8 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.3.12-uncompiled';
+// eslint-disable-next-line no-useless-concat
+shaka.Player.version = 'v4.3.14' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/media_capabilities.js

@@ -141,8 +141,15 @@ shaka.polyfill.MediaCapabilities = class {
       }
 
       if (audioConfig) {
-        const contentType = audioConfig.contentType;
-        const isSupported = Capabilities.isTypeSupported(contentType);
+        let isSupported;
+        if (shaka.util.Platform.isChromecast() &&
+            audioConfig.spatialRendering) {
+          const extendedType =
+              audioConfig.contentType + '; spatialRendering=true';
+          isSupported = Capabilities.isTypeSupported(extendedType);
+        } else {
+          isSupported = Capabilities.isTypeSupported(audioConfig.contentType);
+        }
         if (!isSupported) {
           return res;
         }
@@ -184,10 +191,23 @@ shaka.polyfill.MediaCapabilities = class {
       const videoCapabilities = [];
 
       if (mediaCapkeySystemConfig.audio) {
-        const capability = {
+        let capability = {
           robustness: mediaCapkeySystemConfig.audio.robustness || '',
           contentType: mediaDecodingConfig.audio.contentType,
         };
+
+        // Some Tizen devices seem to misreport AC-3 support, but correctly
+        // report EC-3 support. So query EC-3 as a fallback for AC-3.
+        // See https://github.com/shaka-project/shaka-player/issues/2989 for
+        // details.
+        if (shaka.util.Platform.isTizen() &&
+          mediaDecodingConfig.audio.contentType.includes('codecs="ac-3"')) {
+          capability = {
+            robustness: capability.robustness,
+            contentType: 'audio/mp4; codecs="ec-3"',
+          };
+        }
+
         audioCapabilities.push(capability);
       }
 

package/lib/text/mp4_ttml_parser.js

@@ -67,7 +67,7 @@ shaka.text.Mp4TtmlParser = class {
    * @override
    * @export
    */
-  parseMedia(data, time) {
+  parseMedia(data, time, uri) {
     const Mp4Parser = shaka.util.Mp4Parser;
 
     let sawMDAT = false;
@@ -78,7 +78,7 @@ shaka.text.Mp4TtmlParser = class {
           sawMDAT = true;
           // Join this to any previous payload, in case the mp4 has multiple
           // mdats.
-          payload = payload.concat(this.parser_.parseMedia(data, time));
+          payload = payload.concat(this.parser_.parseMedia(data, time, uri));
         }));
     parser.parse(data, /* partialOkay= */ false);
 

package/lib/text/simple_text_displayer.js

@@ -6,7 +6,6 @@
 
 /**
  * @fileoverview
- * @suppress {missingRequire} TODO(b/152540451): this shouldn't be needed
  */
 
 goog.provide('shaka.text.SimpleTextDisplayer');
@@ -24,8 +23,11 @@ goog.require('shaka.text.Utils');
  * @export
  */
 shaka.text.SimpleTextDisplayer = class {
-  /** @param {HTMLMediaElement} video */
-  constructor(video) {
+  /**
+   * @param {HTMLMediaElement} video
+   * @param {string} label
+   */
+  constructor(video, label) {
     /** @private {TextTrack} */
     this.textTrack_ = null;
 
@@ -39,7 +41,7 @@ shaka.text.SimpleTextDisplayer = class {
       // element.
       track.mode = 'disabled';
 
-      if (track.label == shaka.Player.TextTrackLabel) {
+      if (track.label == label) {
         this.textTrack_ = track;
       }
     }
@@ -49,8 +51,7 @@ shaka.text.SimpleTextDisplayer = class {
       // kind to 'subtitles' or 'captions' when creating the TextTrack object.
       // The individual text tracks from the manifest will still have their own
       // kinds which can be displayed in the app's UI.
-      this.textTrack_ = video.addTextTrack(
-          'subtitles', shaka.Player.TextTrackLabel);
+      this.textTrack_ = video.addTextTrack('subtitles', label);
     }
     this.textTrack_.mode = 'hidden';
   }

package/lib/text/srt_text_parser.js

@@ -47,7 +47,7 @@ shaka.text.SrtTextParser = class {
    * @override
    * @export
    */
-  parseMedia(data, time) {
+  parseMedia(data, time, uri) {
     const SrtTextParser = shaka.text.SrtTextParser;
     const BufferUtils = shaka.util.BufferUtils;
     const StringUtils = shaka.util.StringUtils;
@@ -59,7 +59,7 @@ shaka.text.SrtTextParser = class {
 
     const newData = BufferUtils.toUint8(StringUtils.toUTF8(vvtText));
 
-    return this.parser_.parseMedia(newData, time);
+    return this.parser_.parseMedia(newData, time, uri);
   }
 
   /**