shaka-player 4.4.0 → 4.4.2

package/lib/transmuxer/ts_transmuxer.js

@@ -159,7 +159,8 @@ shaka.transmuxer.TsTransmuxer = class {
    * @override
    * @export
    */
-  transmux(data, stream, reference, duration) {
+  transmux(data, stream, reference, duration, contentType) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (!this.tsParser_) {
       this.tsParser_ = new shaka.util.TsParser();
     } else {
@@ -169,57 +170,46 @@ shaka.transmuxer.TsTransmuxer = class {
 
     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
 
-    let timestamp = reference.endTime * 1000;
-
     const tsParser = this.tsParser_.parse(uint8ArrayData);
-    const startTime = tsParser.getStartTime();
-
-    if (startTime.audio != null) {
-      timestamp = startTime.audio;
-    }
-    if (startTime.video != null) {
-      timestamp = startTime.video;
-    }
     const streamInfos = [];
     const codecs = tsParser.getCodecs();
     try {
       let streamInfo = null;
-      switch (codecs.video) {
-        case 'avc':
-          streamInfo =
-            this.getAvcStreamInfo_(tsParser, timestamp, stream, duration);
-          break;
-      }
-      if (streamInfo) {
-        streamInfos.push(streamInfo);
-        streamInfo = null;
-      }
-      const isMuxed = !!(codecs.video && codecs.audio);
-      switch (codecs.audio) {
-        case 'aac':
-          streamInfo =
-            this.getAacStreamInfo_(
-                tsParser, timestamp, stream, duration, isMuxed);
-          break;
-        case 'ac3':
-          streamInfo =
-            this.getAc3StreamInfo_(
-                tsParser, timestamp, stream, duration, isMuxed);
-          break;
-        case 'ec3':
-          streamInfo =
-            this.getEc3StreamInfo_(
-                tsParser, timestamp, stream, duration, isMuxed);
-          break;
-        case 'mp3':
-          streamInfo =
-            this.getMp3StreamInfo_(
-                tsParser, timestamp, stream, duration, isMuxed);
-          break;
+      if (contentType == ContentType.VIDEO) {
+        switch (codecs.video) {
+          case 'avc':
+            streamInfo =
+              this.getAvcStreamInfo_(tsParser, stream, duration);
+            break;
+        }
+        if (streamInfo) {
+          streamInfos.push(streamInfo);
+          streamInfo = null;
+        }
       }
-      if (streamInfo) {
-        streamInfos.push(streamInfo);
-        streamInfo = null;
+      if (contentType == ContentType.AUDIO) {
+        switch (codecs.audio) {
+          case 'aac':
+            streamInfo =
+              this.getAacStreamInfo_(tsParser, stream, duration);
+            break;
+          case 'ac3':
+            streamInfo =
+              this.getAc3StreamInfo_(tsParser, stream, duration);
+            break;
+          case 'ec3':
+            streamInfo =
+              this.getEc3StreamInfo_(tsParser, stream, duration);
+            break;
+          case 'mp3':
+            streamInfo =
+              this.getMp3StreamInfo_(tsParser, stream, duration);
+            break;
+        }
+        if (streamInfo) {
+          streamInfos.push(streamInfo);
+          streamInfo = null;
+        }
       }
     } catch (e) {
       return Promise.reject(e);
@@ -250,21 +240,22 @@ shaka.transmuxer.TsTransmuxer = class {
 
   /**
    * @param {shaka.util.TsParser} tsParser
-   * @param {number} timestamp
    * @param {shaka.extern.Stream} stream
    * @param {number} duration
-   * @param {boolean} isMuxed
    * @return {shaka.util.Mp4Generator.StreamInfo}
    * @private
    */
-  getAacStreamInfo_(tsParser, timestamp, stream, duration, isMuxed) {
+  getAacStreamInfo_(tsParser, stream, duration) {
     const ADTS = shaka.transmuxer.ADTS;
+    const timescale = shaka.util.TsParser.Timescale;
 
     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
     const samples = [];
 
     let info;
 
+    let firstPts = null;
+
     for (const audioData of tsParser.getAudioData()) {
       const data = audioData.data;
       if (!data) {
@@ -280,8 +271,9 @@ shaka.transmuxer.TsTransmuxer = class {
       }
       stream.audioSamplingRate = info.sampleRate;
       stream.channelsCount = info.channelCount;
-      stream.codecs = info.codec;
-
+      if (firstPts == null && audioData.pts !== null) {
+        firstPts = audioData.pts;
+      }
       while (offset < data.length) {
         const header = ADTS.parseHeader(data, offset);
         if (!header) {
@@ -313,7 +305,7 @@ shaka.transmuxer.TsTransmuxer = class {
       }
     }
 
-    if (!info) {
+    if (!info || firstPts == null) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.MEDIA,
@@ -323,15 +315,12 @@ shaka.transmuxer.TsTransmuxer = class {
     /** @type {number} */
     const sampleRate = info.sampleRate;
     /** @type {number} */
-    const baseMediaDecodeTime = Math.floor(timestamp * sampleRate / 1000);
+    const baseMediaDecodeTime = firstPts / timescale * sampleRate;
 
-    let id = stream.id;
-    if (isMuxed) {
-      id += shaka.transmuxer.TsTransmuxer.START_ID_FOR_MUXED_CONTENT_;
-    }
     return {
-      id: id,
+      id: stream.id,
       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
+      codecs: info.codec,
       encrypted: stream.encrypted && stream.drmInfos.length > 0,
       timescale: sampleRate,
       duration: duration,
@@ -350,15 +339,14 @@ shaka.transmuxer.TsTransmuxer = class {
 
   /**
    * @param {shaka.util.TsParser} tsParser
-   * @param {number} timestamp
    * @param {shaka.extern.Stream} stream
    * @param {number} duration
-   * @param {boolean} isMuxed
    * @return {shaka.util.Mp4Generator.StreamInfo}
    * @private
    */
-  getAc3StreamInfo_(tsParser, timestamp, stream, duration, isMuxed) {
+  getAc3StreamInfo_(tsParser, stream, duration) {
     const Ac3 = shaka.transmuxer.Ac3;
+    const timescale = shaka.util.TsParser.Timescale;
 
     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
     const samples = [];
@@ -369,8 +357,13 @@ shaka.transmuxer.TsTransmuxer = class {
     /** @type {!Uint8Array} */
     let audioConfig = new Uint8Array([]);
 
+    let firstPts = null;
+
     for (const audioData of tsParser.getAudioData()) {
       const data = audioData.data;
+      if (firstPts == null && audioData.pts !== null) {
+        firstPts = audioData.pts;
+      }
       let offset = 0;
       while (offset < data.length) {
         const frame = Ac3.parseFrame(data, offset);
@@ -404,7 +397,7 @@ shaka.transmuxer.TsTransmuxer = class {
       }
     }
 
-    if (sampleRate == 0 || audioConfig.byteLength == 0) {
+    if (sampleRate == 0 || audioConfig.byteLength == 0 || firstPts == null) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.MEDIA,
@@ -413,15 +406,12 @@ shaka.transmuxer.TsTransmuxer = class {
 
 
     /** @type {number} */
-    const baseMediaDecodeTime = Math.floor(timestamp * sampleRate / 1000);
+    const baseMediaDecodeTime = firstPts / timescale * sampleRate;
 
-    let id = stream.id;
-    if (isMuxed) {
-      id += shaka.transmuxer.TsTransmuxer.START_ID_FOR_MUXED_CONTENT_;
-    }
     return {
-      id: id,
+      id: stream.id,
       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
+      codecs: 'ac-3',
       encrypted: stream.encrypted && stream.drmInfos.length > 0,
       timescale: sampleRate,
       duration: duration,
@@ -440,15 +430,14 @@ shaka.transmuxer.TsTransmuxer = class {
 
   /**
    * @param {shaka.util.TsParser} tsParser
-   * @param {number} timestamp
    * @param {shaka.extern.Stream} stream
    * @param {number} duration
-   * @param {boolean} isMuxed
    * @return {shaka.util.Mp4Generator.StreamInfo}
    * @private
    */
-  getEc3StreamInfo_(tsParser, timestamp, stream, duration, isMuxed) {
+  getEc3StreamInfo_(tsParser, stream, duration) {
     const Ec3 = shaka.transmuxer.Ec3;
+    const timescale = shaka.util.TsParser.Timescale;
 
     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
     const samples = [];
@@ -459,8 +448,13 @@ shaka.transmuxer.TsTransmuxer = class {
     /** @type {!Uint8Array} */
     let audioConfig = new Uint8Array([]);
 
+    let firstPts = null;
+
     for (const audioData of tsParser.getAudioData()) {
       const data = audioData.data;
+      if (firstPts == null && audioData.pts !== null) {
+        firstPts = audioData.pts;
+      }
       let offset = 0;
       while (offset < data.length) {
         const frame = Ec3.parseFrame(data, offset);
@@ -494,7 +488,7 @@ shaka.transmuxer.TsTransmuxer = class {
       }
     }
 
-    if (sampleRate == 0 || audioConfig.byteLength == 0) {
+    if (sampleRate == 0 || audioConfig.byteLength == 0 || firstPts == null) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.MEDIA,
@@ -503,15 +497,12 @@ shaka.transmuxer.TsTransmuxer = class {
 
 
     /** @type {number} */
-    const baseMediaDecodeTime = Math.floor(timestamp * sampleRate / 1000);
+    const baseMediaDecodeTime = firstPts / timescale * sampleRate;
 
-    let id = stream.id;
-    if (isMuxed) {
-      id += shaka.transmuxer.TsTransmuxer.START_ID_FOR_MUXED_CONTENT_;
-    }
     return {
-      id: id,
+      id: stream.id,
       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
+      codecs: 'ec-3',
       encrypted: stream.encrypted && stream.drmInfos.length > 0,
       timescale: sampleRate,
       duration: duration,
@@ -530,26 +521,30 @@ shaka.transmuxer.TsTransmuxer = class {
 
   /**
    * @param {shaka.util.TsParser} tsParser
-   * @param {number} timestamp
    * @param {shaka.extern.Stream} stream
    * @param {number} duration
-   * @param {boolean} isMuxed
    * @return {shaka.util.Mp4Generator.StreamInfo}
    * @private
    */
-  getMp3StreamInfo_(tsParser, timestamp, stream, duration, isMuxed) {
+  getMp3StreamInfo_(tsParser, stream, duration) {
     const MpegAudio = shaka.transmuxer.MpegAudio;
+    const timescale = shaka.util.TsParser.Timescale;
 
     /** @type {!Array.<shaka.util.Mp4Generator.Mp4Sample>} */
     const samples = [];
 
     let firstHeader;
 
+    let firstPts = null;
+
     for (const audioData of tsParser.getAudioData()) {
       const data = audioData.data;
       if (!data) {
         continue;
       }
+      if (firstPts == null && audioData.pts !== null) {
+        firstPts = audioData.pts;
+      }
       let offset = 0;
       while (offset < data.length) {
         const header = MpegAudio.parseHeader(data, offset);
@@ -579,7 +574,7 @@ shaka.transmuxer.TsTransmuxer = class {
         offset += header.frameLength;
       }
     }
-    if (!firstHeader) {
+    if (!firstHeader || firstPts == null) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.MEDIA,
@@ -588,15 +583,12 @@ shaka.transmuxer.TsTransmuxer = class {
     /** @type {number} */
     const sampleRate = firstHeader.sampleRate;
     /** @type {number} */
-    const baseMediaDecodeTime = Math.floor(timestamp * sampleRate / 1000);
+    const baseMediaDecodeTime = firstPts / timescale * sampleRate;
 
-    let id = stream.id;
-    if (isMuxed) {
-      id += shaka.transmuxer.TsTransmuxer.START_ID_FOR_MUXED_CONTENT_;
-    }
     return {
-      id: id,
+      id: stream.id,
       type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
+      codecs: 'mp3',
       encrypted: stream.encrypted && stream.drmInfos.length > 0,
       timescale: sampleRate,
       duration: duration,
@@ -615,13 +607,12 @@ shaka.transmuxer.TsTransmuxer = class {
 
   /**
    * @param {shaka.util.TsParser} tsParser
-   * @param {number} timestamp
    * @param {shaka.extern.Stream} stream
    * @param {number} duration
    * @return {shaka.util.Mp4Generator.StreamInfo}
    * @private
    */
-  getAvcStreamInfo_(tsParser, timestamp, stream, duration) {
+  getAvcStreamInfo_(tsParser, stream, duration) {
     const H264 = shaka.transmuxer.H264;
     const timescale = shaka.util.TsParser.Timescale;
 
@@ -632,9 +623,7 @@ shaka.transmuxer.TsTransmuxer = class {
     let baseMediaDecodeTime = null;
 
     let nalus = [];
-    const videoData = tsParser.getVideoData().filter((pes) => {
-      return pes.pts != null && pes.dts != null;
-    });
+    const videoData = tsParser.getVideoData();
     for (let i = 0; i < videoData.length; i++) {
       const pes = videoData[i];
       let nextPes;
@@ -647,7 +636,7 @@ shaka.transmuxer.TsTransmuxer = class {
       if (!frame) {
         continue;
       }
-      if (baseMediaDecodeTime == null && pes.dts != null) {
+      if (baseMediaDecodeTime == null) {
         baseMediaDecodeTime = pes.dts;
       }
       let duration;
@@ -686,6 +675,7 @@ shaka.transmuxer.TsTransmuxer = class {
     return {
       id: stream.id,
       type: shaka.util.ManifestParserUtils.ContentType.VIDEO,
+      codecs: 'avc1',
       encrypted: stream.encrypted && stream.drmInfos.length > 0,
       timescale: timescale,
       duration: duration,
@@ -725,12 +715,6 @@ shaka.transmuxer.TsTransmuxer.SUPPORTED_VIDEO_CODECS_ = [
   'avc',
 ];
 
-/**
- * @private
- * @const {number}
- */
-shaka.transmuxer.TsTransmuxer.START_ID_FOR_MUXED_CONTENT_ = 128;
-
 
 shaka.transmuxer.TransmuxerEngine.registerTransmuxer(
     'video/mp2t',

package/lib/util/error.js

@@ -63,8 +63,11 @@ shaka.util.Error = class {
      */
     this.handled = false;
 
-    // This improves the formatting of Errors in failure messages in the tests.
+    // A basic message for compiled mode.
+    let formattedMessage = 'Shaka Error ' + this.code;
     if (goog.DEBUG) {
+      // This improves the formatting of Errors in failure messages in the
+      // tests in debug mode.
       let categoryName = 'UNKNOWN';
       let codeName = 'UNKNOWN';
 
@@ -79,17 +82,20 @@ shaka.util.Error = class {
         }
       }
 
-      /**
-       * A human-readable version of the category and code.
-       * <i>(Only available in uncompiled mode.)</i>
-       *
-       * @const {string}
-       * @exportDoc
-       */
-      this.message = 'Shaka Error ' + categoryName + '.' + codeName +
-                     ' (' + this.data.toString() + ')';
+      formattedMessage = 'Shaka Error ' + categoryName + '.' + codeName +
+                         ' (' + this.data.toString() + ')';
     }
 
+    /**
+     * In compiled mode, contains a basic message string with the error code.
+     * In uncompiled and debug modes, contains a human-readable version of the
+     * category and code as enums.
+     *
+     * @const {string}
+     * @exportDoc
+     */
+    this.message = formattedMessage;
+
     if (shaka.util.Error.createStack) {
       try {
         throw new Error(this.message || 'Shaka Error');

package/lib/util/mp4_generator.js

@@ -55,7 +55,7 @@ shaka.util.Mp4Generator = class {
     return Mp4Generator.box('moov',
         this.mvhd_(firstStreamInfo),
         traks,
-        this.mvex_(firstStreamInfo),
+        this.mvex_(),
         this.pssh_(firstStreamInfo));
   }
 
@@ -130,9 +130,14 @@ shaka.util.Mp4Generator = class {
    */
   tkhd_(streamInfo) {
     const Mp4Generator = shaka.util.Mp4Generator;
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const id = streamInfo.id + 1;
-    const width = streamInfo.stream.width || 0;
-    const height = streamInfo.stream.height || 0;
+    let width = streamInfo.stream.width || 0;
+    let height = streamInfo.stream.height || 0;
+    if (streamInfo.type == ContentType.AUDIO) {
+      width = 0;
+      height = 0;
+    }
     const duration = streamInfo.duration * streamInfo.timescale;
     const upperWordDuration =
         Math.floor(duration / (Mp4Generator.UINT32_MAX_ + 1));
@@ -295,24 +300,18 @@ shaka.util.Mp4Generator = class {
     let bytes = new Uint8Array([]);
     switch (streamInfo.type) {
       case ContentType.VIDEO:
-        if (streamInfo.stream.codecs.includes('avc1.') ||
-            streamInfo.stream.codecs.includes('avc3.')) {
+        if (streamInfo.codecs.includes('avc1')) {
           bytes = this.avc1_(streamInfo);
-        } else if (streamInfo.stream.codecs.includes('hev1.') ||
-            streamInfo.stream.codecs.includes('hvc1.')) {
+        } else if (streamInfo.codecs.includes('hvc1')) {
           bytes = this.hvc1_(streamInfo);
         }
         break;
       case ContentType.AUDIO:
-        if (streamInfo.stream.mimeType === 'audio/mpeg' ||
-            streamInfo.stream.codecs.includes('mp3') ||
-            streamInfo.stream.codecs.includes('mp4a.40.34')) {
+        if (streamInfo.codecs.includes('mp3')) {
           bytes = this.mp3_(streamInfo);
-        } else if (streamInfo.stream.mimeType === 'audio/ac3' ||
-            streamInfo.stream.codecs.includes('ac-3')) {
+        } else if (streamInfo.codecs.includes('ac-3')) {
           bytes = this.ac3_(streamInfo);
-        } else if (streamInfo.stream.mimeType === 'audio/ec3' ||
-            streamInfo.stream.codecs.includes('ec-3')) {
+        } else if (streamInfo.codecs.includes('ec-3')) {
           bytes = this.ec3_(streamInfo);
         } else {
           bytes = this.mp4a_(streamInfo);
@@ -630,7 +629,7 @@ shaka.util.Mp4Generator = class {
     const audioSamplingRate = streamInfo.stream.audioSamplingRate || 44100;
 
     const audioCodec = shaka.util.ManifestParserUtils.guessCodecs(
-        ContentType.AUDIO, streamInfo.stream.codecs.split(','));
+        ContentType.AUDIO, streamInfo.codecs.split(','));
 
     const samplingFrequencyIndex = {
       96000: 0x0,
@@ -689,13 +688,16 @@ shaka.util.Mp4Generator = class {
   /**
    * Generate a MVEX box
    *
-   * @param {shaka.util.Mp4Generator.StreamInfo} streamInfo
    * @return {!Uint8Array}
    * @private
    */
-  mvex_(streamInfo) {
+  mvex_() {
     const Mp4Generator = shaka.util.Mp4Generator;
-    return Mp4Generator.box('mvex', this.trex_(streamInfo));
+    let trexs = new Uint8Array([]);
+    for (const streamInfo of this.streamInfos_) {
+      trexs = shaka.util.Uint8ArrayUtils.concat(trexs, this.trex_(streamInfo));
+    }
+    return Mp4Generator.box('mvex', trexs);
   }
 
   /**
@@ -765,8 +767,8 @@ shaka.util.Mp4Generator = class {
    * @private
    */
   frma_(streamInfo) {
-    const codec = streamInfo.stream.codecs.substring(
-        0, streamInfo.stream.codecs.indexOf('.'));
+    const codec = streamInfo.codecs.substring(
+        0, streamInfo.codecs.indexOf('.'));
     const Mp4Generator = shaka.util.Mp4Generator;
     const codecNumber = this.stringToCharCode_(codec);
     const bytes = new Uint8Array([
@@ -1290,6 +1292,7 @@ shaka.util.Mp4Generator.DINF_ = new Uint8Array([]);
  * @typedef {{
  *    id: number,
  *    type: string,
+ *    codecs: string,
  *    encrypted: boolean,
  *    timescale: number,
  *    duration: number,
@@ -1304,6 +1307,10 @@ shaka.util.Mp4Generator.DINF_ = new Uint8Array([]);
  *   A unique ID
  * @property {string} type
  *   Indicate the content type: 'video' or 'audio'.
+ * @property {string} codecs
+ *   <i>Defaults to '' (i.e., unknown / not needed).</i> <br>
+ *   The Stream's codecs, e.g., 'avc1.4d4015' or 'vp9'<br>
+ *   See {@link https://tools.ietf.org/html/rfc6381}
  * @property {boolean} encrypted
  *   Indicate if the stream is encrypted.
  * @property {number} timescale

package/lib/util/player_configuration.js

@@ -71,8 +71,8 @@ shaka.util.PlayerConfiguration = class {
       persistentSessionOnlinePlayback: false,
       persistentSessionsMetadata: [],
       initDataTransform: (initData, initDataType, drmInfo) => {
-        const keySystem = drmInfo.keySystem;
-        if (keySystem == 'com.apple.fps.1_0' && initDataType == 'skd') {
+        if (shaka.util.Platform.isMediaKeysPolyfilled() &&
+            initDataType == 'skd') {
           const cert = drmInfo.serverCertificate;
           const contentId =
               shaka.util.FairPlayUtils.defaultGetContentId(initData);

package/lib/util/stream_utils.js

@@ -1543,22 +1543,23 @@ shaka.util.StreamUtils = class {
 
   /**
    * Chooses streams according to the given config.
+   * Works both for Stream and Track types due to their similarities.
    *
-   * @param {!Array.<shaka.extern.Stream>} streams
+   * @param {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} streams
    * @param {string} preferredLanguage
    * @param {string} preferredRole
    * @param {boolean} preferredForced
-   * @return {!Array.<!shaka.extern.Stream>}
+   * @return {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>}
    */
   static filterStreamsByLanguageAndRole(
       streams, preferredLanguage, preferredRole, preferredForced) {
     const LanguageUtils = shaka.util.LanguageUtils;
 
-    /** @type {!Array.<!shaka.extern.Stream>} */
+    /** @type {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} */
     let chosen = streams;
 
     // Start with the set of primary streams.
-    /** @type {!Array.<!shaka.extern.Stream>} */
+    /** @type {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} */
     const primary = streams.filter((stream) => {
       return stream.primary;
     });
@@ -1598,7 +1599,7 @@ shaka.util.StreamUtils = class {
 
     // Now refine the choice based on role preference.
     if (preferredRole) {
-      const roleMatches = shaka.util.StreamUtils.filterTextStreamsByRole_(
+      const roleMatches = shaka.util.StreamUtils.filterStreamsByRole_(
           chosen, preferredRole);
       if (roleMatches.length) {
         return roleMatches;
@@ -1626,20 +1627,21 @@ shaka.util.StreamUtils = class {
     if (!allRoles.length) {
       return chosen;
     }
-    return shaka.util.StreamUtils.filterTextStreamsByRole_(chosen, allRoles[0]);
+    return shaka.util.StreamUtils.filterStreamsByRole_(chosen, allRoles[0]);
   }
 
 
   /**
-   * Filter text Streams by role.
+   * Filter Streams by role.
+   * Works both for Stream and Track types due to their similarities.
    *
-   * @param {!Array.<shaka.extern.Stream>} textStreams
+   * @param {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} streams
    * @param {string} preferredRole
-   * @return {!Array.<shaka.extern.Stream>}
+   * @return {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>}
    * @private
    */
-  static filterTextStreamsByRole_(textStreams, preferredRole) {
-    return textStreams.filter((stream) => {
+  static filterStreamsByRole_(streams, preferredRole) {
+    return streams.filter((stream) => {
       return stream.roles.includes(preferredRole);
     });
   }