Source: lib/util/stream_utils.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.util.StreamUtils');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.media.DrmEngine');
  23. goog.require('shaka.media.MediaSourceEngine');
  24. goog.require('shaka.text.TextEngine');
  25. goog.require('shaka.util.ArrayUtils');
  26. goog.require('shaka.util.Functional');
  27. goog.require('shaka.util.LanguageUtils');
  28. goog.require('shaka.util.ManifestParserUtils');
  29. goog.require('shaka.util.MimeUtils');
  32. /**
  33.  * @namespace shaka.util.StreamUtils
  34.  * @summary A set of utility functions for dealing with Streams and Manifests.
  35.  */
  38. /**
  39.  * @param {shakaExtern.Variant} variant
  40.  * @param {shakaExtern.Restrictions} restrictions
  41.  *   Configured restrictions from the user.
  42.  * @param {{width: number, height: number}} maxHwRes
  43.  *   The maximum resolution the hardware can handle.
  44.  *   This is applied separately from user restrictions because the setting
  45.  *   should not be easily replaced by the user's configuration.
  46.  * @return {boolean}
  47.  */
  48. shaka.util.StreamUtils.meetsRestrictions = function(
  49.     variant, restrictions, maxHwRes) {
  50.   let video = variant.video;
  51.   if (video) {
  52.     if (video.width < restrictions.minWidth ||
  53.         video.width > restrictions.maxWidth || video.width > maxHwRes.width ||
  54.         video.height < restrictions.minHeight ||
  55.         video.height > restrictions.maxHeight ||
  56.         video.height > maxHwRes.height ||
  57.         (video.width * video.height) < restrictions.minPixels ||
  58.         (video.width * video.height) > restrictions.maxPixels) {
  59.       return false;
  60.     }
  61.   }
  63.   if (variant.bandwidth < restrictions.minBandwidth ||
  64.       variant.bandwidth > restrictions.maxBandwidth) {
  65.     return false;
  66.   }
  68.   return true;
  69. };
  72. /**
  73.  * @param {shakaExtern.Period} period
  74.  * @param {shakaExtern.Restrictions} restrictions
  75.  * @param {{width: number, height: number}} maxHwRes
  76.  * @return {boolean} Whether the tracks changed.
  77.  */
  78. shaka.util.StreamUtils.applyRestrictions =
  79.     function(period, restrictions, maxHwRes) {
  80.   let tracksChanged = false;
  82.   period.variants.forEach(function(variant) {
  83.     let originalAllowed = variant.allowedByApplication;
  84.     variant.allowedByApplication = shaka.util.StreamUtils.meetsRestrictions(
  85.         variant, restrictions, maxHwRes);
  87.     if (originalAllowed != variant.allowedByApplication) {
  88.       tracksChanged = true;
  89.     }
  90.   });
  92.   return tracksChanged;
  93. };
  96. /**
  97.  * Alters the given Period to filter out any unplayable streams.
  98.  *
  99.  * @param {shaka.media.DrmEngine} drmEngine
  100.  * @param {?shakaExtern.Stream} activeAudio
  101.  * @param {?shakaExtern.Stream} activeVideo
  102.  * @param {shakaExtern.Period} period
  103.  */
  104. shaka.util.StreamUtils.filterNewPeriod = function(
  105.     drmEngine, activeAudio, activeVideo, period) {
  106.   const StreamUtils = shaka.util.StreamUtils;
  108.   if (activeAudio) {
  109.     goog.asserts.assert(
  110.         shaka.util.StreamUtils.isAudio(activeAudio),
  111.         'Audio streams must have the audio type.');
  112.   }
  114.   if (activeVideo) {
  115.     goog.asserts.assert(
  116.         shaka.util.StreamUtils.isVideo(activeVideo),
  117.         'Video streams must have the video type.');
  118.   }
  120.   // Filter variants.
  121.   period.variants = period.variants.filter(function(variant) {
  122.     let keep = StreamUtils.isVariantCompatible_(
  123.         variant,
  124.         drmEngine,
  125.         activeAudio,
  126.         activeVideo);
  128.     if (!keep) {
  129.       shaka.log.debug('Dropping Variant (not compatible with key system, ' +
  130.                       'platform, or active Variant)', variant);
  131.     }
  133.     return keep;
  134.   });
  136.   // Filter text streams.
  137.   period.textStreams = period.textStreams.filter(function(stream) {
  138.     let fullMimeType = shaka.util.MimeUtils.getFullType(
  139.         stream.mimeType, stream.codecs);
  140.     let keep = shaka.text.TextEngine.isTypeSupported(fullMimeType);
  142.     if (!keep) {
  143.       shaka.log.debug('Dropping text stream. Is not supported by the ' +
  144.                       'platform.', stream);
  145.     }
  147.     return keep;
  148.   });
  149. };
  152. /**
  153.  * Checks if a stream is compatible with the key system, platform,
  154.  * and active stream.
  155.  * This does not check if the stream is supported by the chosen key system.
  156.  *
  157.  * @param {?shakaExtern.Stream} stream A non-text stream to check.
  158.  * @param {shaka.media.DrmEngine} drmEngine
  159.  * @param {?shakaExtern.Stream} activeStream
  160.  * @return {boolean}
  161.  * @private
  162.  */
  163. shaka.util.StreamUtils.isStreamCompatible_ =
  164.     function(stream, drmEngine, activeStream) {
  165.   if (!stream) return true;
  167.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  168.   goog.asserts.assert(stream.type != ContentType.TEXT,
  169.       'Should not be called on a text stream!');
  171.   let drmSupportedMimeTypes = null;
  172.   if (drmEngine && drmEngine.initialized()) {
  173.     drmSupportedMimeTypes = drmEngine.getSupportedTypes();
  174.   }
  176.   // Check if the stream can be played by the platform.
  177.   let fullMimeType = shaka.util.MimeUtils.getFullType(
  178.       stream.mimeType, stream.codecs);
  180.   if (!shaka.media.MediaSourceEngine.isStreamSupported(stream)) {
  181.     return false;
  182.   }
  184.   // Check if the stream can be handled by the key system.
  185.   // There's no need to check that the stream is supported by the
  186.   // chosen key system since the caller has already verified that.
  187.   if (drmSupportedMimeTypes && stream.encrypted &&
  188.       drmSupportedMimeTypes.indexOf(fullMimeType) < 0) {
  189.     return false;
  190.   }
  192.   // Lastly, check if the active stream can switch to the stream.
  193.   // Basic mime types and basic codecs need to match.
  194.   // For example, we can't adapt between WebM and MP4,
  195.   // nor can we adapt between mp4a.* to ec-3.
  196.   // We can switch between text types on the fly,
  197.   // so don't run this check on text.
  198.   if (activeStream) {
  199.     if (stream.mimeType != activeStream.mimeType ||
  200.         stream.codecs.split('.')[0] != activeStream.codecs.split('.')[0]) {
  201.       return false;
  202.     }
  203.   }
  205.   return true;
  206. };
  209. /**
  210.  * Checks if a variant is compatible with the key system, platform,
  211.  * and active stream.
  212.  *
  213.  * @param {!shakaExtern.Variant} variant
  214.  * @param {shaka.media.DrmEngine} drmEngine
  215.  * @param {?shakaExtern.Stream} activeAudio
  216.  * @param {?shakaExtern.Stream} activeVideo
  217.  * @return {boolean}
  218.  * @private
  219.  */
  220. shaka.util.StreamUtils.isVariantCompatible_ =
  221.     function(variant, drmEngine, activeAudio, activeVideo) {
  222.   if (drmEngine && drmEngine.initialized()) {
  223.     if (!drmEngine.isSupportedByKeySystem(variant)) return false;
  224.   }
  226.   let isStreamCompatible = shaka.util.StreamUtils.isStreamCompatible_;
  228.   return isStreamCompatible(variant.audio, drmEngine, activeAudio) &&
  229.          isStreamCompatible(variant.video, drmEngine, activeVideo);
  230. };
  233. /**
  234.  * @param {shakaExtern.Variant} variant
  235.  * @return {shakaExtern.Track}
  236.  */
  237. shaka.util.StreamUtils.variantToTrack = function(variant) {
  238.   /** @type {?shakaExtern.Stream} */
  239.   let audio = variant.audio;
  240.   /** @type {?shakaExtern.Stream} */
  241.   let video = variant.video;
  243.   /** @type {?string} */
  244.   let audioCodec = audio ? audio.codecs : null;
  245.   /** @type {?string} */
  246.   let videoCodec = video ? video.codecs : null;
  248.   /** @type {!Array.<string>} */
  249.   let codecs = [];
  250.   if (videoCodec) codecs.push(videoCodec);
  251.   if (audioCodec) codecs.push(audioCodec);
  253.   /** @type {!Array.<string>} */
  254.   let mimeTypes = [];
  255.   if (video) mimeTypes.push(video.mimeType);
  256.   if (audio) mimeTypes.push(audio.mimeType);
  257.   /** @type {?string} */
  258.   let mimeType = mimeTypes[0] || null;
  260.   /** @type {!Array.<string>} */
  261.   let kinds = [];
  262.   if (audio) kinds.push(audio.kind);
  263.   if (video) kinds.push(video.kind);
  264.   /** @type {?string} */
  265.   let kind = kinds[0] || null;
  267.   /** @type {!Array.<string>} */
  268.   let roles = [];
  269.   if (audio) roles.push.apply(roles, audio.roles);
  270.   if (video) roles.push.apply(roles, video.roles);
  271.   roles = shaka.util.ArrayUtils.removeDuplicates(roles);
  273.   /** @type {shakaExtern.Track} */
  274.   let track = {
  275.     id: variant.id,
  276.     active: false,
  277.     type: 'variant',
  278.     bandwidth: variant.bandwidth,
  279.     language: variant.language,
  280.     label: null,
  281.     kind: kind,
  282.     width: null,
  283.     height: null,
  284.     frameRate: null,
  285.     mimeType: mimeType,
  286.     codecs: codecs.join(', '),
  287.     audioCodec: audioCodec,
  288.     videoCodec: videoCodec,
  289.     primary: variant.primary,
  290.     roles: roles,
  291.     videoId: null,
  292.     audioId: null,
  293.     channelsCount: null,
  294.     audioBandwidth: null,
  295.     videoBandwidth: null
  296.   };
  298.   if (video) {
  299.     track.videoId = video.id;
  300.     track.width = video.width || null;
  301.     track.height = video.height || null;
  302.     track.frameRate = video.frameRate || null;
  303.     track.videoBandwidth = video.bandwidth || null;
  304.   }
  306.   if (audio) {
  307.     track.audioId = audio.id;
  308.     track.channelsCount = audio.channelsCount;
  309.     track.audioBandwidth = audio.bandwidth || null;
  310.     track.label = audio.label;
  311.   }
  313.   return track;
  314. };
  317. /**
  318.  * @param {shakaExtern.Stream} stream
  319.  * @return {shakaExtern.Track}
  320.  */
  321. shaka.util.StreamUtils.textStreamToTrack = function(stream) {
  322.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  324.   /** @type {shakaExtern.Track} */
  325.   let track = {
  326.     id: stream.id,
  327.     active: false,
  328.     type: ContentType.TEXT,
  329.     bandwidth: 0,
  330.     language: stream.language,
  331.     label: stream.label,
  332.     kind: stream.kind || null,
  333.     width: null,
  334.     height: null,
  335.     frameRate: null,
  336.     mimeType: stream.mimeType,
  337.     codecs: stream.codecs || null,
  338.     audioCodec: null,
  339.     videoCodec: null,
  340.     primary: stream.primary,
  341.     roles: stream.roles,
  342.     videoId: null,
  343.     audioId: null,
  344.     channelsCount: null,
  345.     audioBandwidth: null,
  346.     videoBandwidth: null
  347.   };
  349.   return track;
  350. };
  353. /**
  354.  * Gets track representations of all playable variants and all text streams.
  355.  *
  356.  * @param {shakaExtern.Period} period
  357.  * @return {!Array.<shakaExtern.Track>}
  358.  */
  359. shaka.util.StreamUtils.getTracks = function(period) {
  360.   const StreamUtils = shaka.util.StreamUtils;
  362.   let tracks = [];
  364.   let variants = StreamUtils.getPlayableVariants(period.variants);
  365.   let textStreams = period.textStreams;
  367.   variants.forEach(function(variant) {
  368.     tracks.push(StreamUtils.variantToTrack(variant));
  369.   });
  371.   textStreams.forEach(function(stream) {
  372.     tracks.push(StreamUtils.textStreamToTrack(stream));
  373.   });
  375.   return tracks;
  376. };
  379. /**
  380.  * Gets an array of Track objects for the given Period.
  381.  *
  382.  * @param {shakaExtern.Period} period
  383.  * @param {?number} activeAudioId
  384.  * @param {?number} activeVideoId
  385.  * @return {!Array.<shakaExtern.Track>}
  386.  */
  387. shaka.util.StreamUtils.getVariantTracks =
  388.     function(period, activeAudioId, activeVideoId) {
  389.   const StreamUtils = shaka.util.StreamUtils;
  390.   let variants = StreamUtils.getPlayableVariants(period.variants);
  392.   return variants.map(function(variant) {
  393.     let track = StreamUtils.variantToTrack(variant);
  395.     if (variant.video && variant.audio) {
  396.       track.active = activeVideoId == variant.video.id &&
  397.                      activeAudioId == variant.audio.id;
  398.     } else if (variant.video) {
  399.       track.active = activeVideoId == variant.video.id;
  400.     } else if (variant.audio) {
  401.       track.active = activeAudioId == variant.audio.id;
  402.     }
  404.     return track;
  405.   });
  406. };
  409. /**
  410.  * Gets an array of text Track objects for the given Period.
  411.  *
  412.  * @param {shakaExtern.Period} period
  413.  * @param {?number} activeStreamId
  414.  * @return {!Array.<shakaExtern.Track>}
  415.  */
  416. shaka.util.StreamUtils.getTextTracks = function(period, activeStreamId) {
  417.   return period.textStreams.map(function(stream) {
  418.     let track = shaka.util.StreamUtils.textStreamToTrack(stream);
  419.     track.active = activeStreamId == stream.id;
  420.     return track;
  421.   });
  422. };
  425. /**
  426.  * Finds the Variant for the given track.
  427.  *
  428.  * @param {shakaExtern.Period} period
  429.  * @param {shakaExtern.Track} track
  430.  * @return {?shakaExtern.Variant}
  431.  */
  432. shaka.util.StreamUtils.findVariantForTrack = function(period, track) {
  433.   for (let i = 0; i < period.variants.length; i++) {
  434.     if (period.variants[i].id == track.id) {
  435.       return period.variants[i];
  436.     }
  437.   }
  438.   return null;
  439. };
  442. /**
  443.  * Finds the text stream for the given track.
  444.  *
  445.  * @param {shakaExtern.Period} period
  446.  * @param {shakaExtern.Track} track
  447.  * @return {?shakaExtern.Stream}
  448.  */
  449. shaka.util.StreamUtils.findTextStreamForTrack = function(period, track) {
  450.   for (let i = 0; i < period.textStreams.length; i++) {
  451.     if (period.textStreams[i].id == track.id) {
  452.       return period.textStreams[i];
  453.     }
  454.   }
  455.   return null;
  456. };
  459. /**
  460.  * Determines if the given variant is playable.
  461.  * @param {!shakaExtern.Variant} variant
  462.  * @return {boolean}
  463.  */
  464. shaka.util.StreamUtils.isPlayable = function(variant) {
  465.   return variant.allowedByApplication && variant.allowedByKeySystem;
  466. };
  469. /**
  470.  * Filters out unplayable variants.
  471.  * @param {!Array.<!shakaExtern.Variant>} variants
  472.  * @return {!Array.<!shakaExtern.Variant>}
  473.  */
  474. shaka.util.StreamUtils.getPlayableVariants = function(variants) {
  475.   return variants.filter(function(variant) {
  476.     return shaka.util.StreamUtils.isPlayable(variant);
  477.   });
  478. };
  481. /**
  482.  * Chooses variants according to the given config.
  483.  *
  484.  * @param {!Array.<shakaExtern.Variant>} variants
  485.  * @param {string} preferredLanguage
  486.  * @param {string} preferredRole
  487.  * @param {number} preferredAudioChannelCount
  488.  * @param {!Object=} languageMatches
  489.  * @return {!Array.<!shakaExtern.Variant>}
  490.  */
  491. shaka.util.StreamUtils.filterVariantsByConfig = function(
  492.     variants, preferredLanguage, preferredRole, preferredAudioChannelCount,
  493.     languageMatches) {
  494.   let chosen = shaka.util.StreamUtils.filterVariantsByLanguageAndRole(
  495.       variants, preferredLanguage, preferredRole, languageMatches);
  496.   return shaka.util.StreamUtils.filterVariantsByAudioChannelCount(chosen,
  497.       preferredAudioChannelCount);
  498. };
  501. /**
  502.  * Chooses variants according to the given config.
  503.  *
  504.  * @param {!Array.<shakaExtern.Variant>} variants
  505.  * @param {string} preferredLanguage
  506.  * @param {string} preferredRole
  507.  * @param {!Object=} languageMatches
  508.  * @return {!Array.<!shakaExtern.Variant>}
  509.  */
  510. shaka.util.StreamUtils.filterVariantsByLanguageAndRole = function(
  511.     variants, preferredLanguage, preferredRole, languageMatches) {
  512.   const LanguageUtils = shaka.util.LanguageUtils;
  513.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  515.   /** @type {!Array.<!shakaExtern.Variant>} */
  516.   let playable = shaka.util.StreamUtils.getPlayableVariants(variants);
  518.   /** @type {!Array.<!shakaExtern.Variant>} */
  519.   let chosen = playable;
  521.   // Start with the set of primary variants.
  522.   /** @type {!Array.<!shakaExtern.Variant>} */
  523.   let primary = playable.filter(function(variant) {
  524.     return variant.primary;
  525.   });
  527.   if (primary.length) {
  528.     chosen = primary;
  529.   }
  531.   // Now reduce the set to one language.  This covers both arbitrary language
  532.   // choices and the reduction of the "primary" variant set to one language.
  533.   let firstLanguage = chosen.length ? chosen[0].language : '';
  534.   chosen = chosen.filter(function(variant) {
  535.     return variant.language == firstLanguage;
  536.   });
  538.   // Now search for matches based on language preference.  If any language match
  539.   // is found, it overrides the selection above.  Favor exact matches, then base
  540.   // matches, finally different subtags.  Execute in reverse order so the later
  541.   // steps override the previous ones.
  542.   if (preferredLanguage) {
  543.     let pref = LanguageUtils.normalize(preferredLanguage);
  544.     [LanguageUtils.MatchType.OTHER_SUB_LANGUAGE_OKAY,
  545.      LanguageUtils.MatchType.BASE_LANGUAGE_OKAY,
  546.      LanguageUtils.MatchType.EXACT]
  547.         .forEach(function(matchType) {
  548.           let betterLangMatchFound = false;
  549.           playable.forEach(function(variant) {
  550.             pref = LanguageUtils.normalize(pref);
  551.             let lang = LanguageUtils.normalize(variant.language);
  552.             if (LanguageUtils.match(matchType, pref, lang)) {
  553.               if (betterLangMatchFound) {
  554.                 chosen.push(variant);
  555.               } else {
  556.                 chosen = [variant];
  557.                 betterLangMatchFound = true;
  558.               }
  559.               if (languageMatches) {
  560.                 languageMatches[ContentType.AUDIO] = true;
  561.               }
  562.             }
  563.           }); // forEach(variant)
  564.         }); // forEach(matchType)
  565.   } // if (preferredLanguage)
  567.   // Now refine the choice based on role preference.
  568.   if (preferredRole) {
  569.     let roleMatches = shaka.util.StreamUtils.filterVariantsByRole_(
  570.         chosen, preferredRole);
  571.     if (roleMatches.length) {
  572.       return roleMatches;
  573.     } else {
  574.       shaka.log.warning('No exact match for the variant role could be found.');
  575.     }
  576.   }
  578.   // Either there was no role preference, or it could not be satisfied.
  579.   // Choose an arbitrary role, if there are any, and filter out any other roles.
  580.   // This ensures we never adapt between roles.
  581.   let allRoles = chosen.map(function(variant) {
  582.     let audioRoles = variant.audio ? variant.audio.roles : [];
  583.     let videoRoles = variant.video ? variant.video.roles : [];
  584.     return audioRoles.concat(videoRoles);
  585.   }).reduce(shaka.util.Functional.collapseArrays, []);
  587.   if (!allRoles.length) {
  588.     return chosen;
  589.   }
  590.   return shaka.util.StreamUtils.filterVariantsByRole_(chosen, allRoles[0]);
  591. };
  594. /**
  595.  * Filters variants according to the given audio channel count config.
  596.  *
  597.  * @param {!Array.<shakaExtern.Variant>} variants
  598.  * @param {number} preferredAudioChannelCount
  599.  * @return {!Array.<!shakaExtern.Variant>}
  600.  */
  601. shaka.util.StreamUtils.filterVariantsByAudioChannelCount = function(
  602.     variants, preferredAudioChannelCount) {
  603.   // Group variants by their audio channel counts.
  604.   let variantsByChannelCount = variants
  605.       .filter((v) => v.audio && v.audio.channelsCount)
  606.       .reduce((map, variant) => {
  607.         let count = variant.audio.channelsCount;
  608.         if (map[count]) {
  609.           map[count].push(variant);
  610.         } else {
  611.           map[count] = [variant];
  612.         }
  613.         return map;
  614.       }, {});
  616.   let channelCounts = Object.keys(variantsByChannelCount);
  618.   // If no variant has audio channel count info, return the original variants.
  619.   if (channelCounts.length == 0) {
  620.     return variants;
  621.   }
  623.   // Choose the variants with the largest number of audio channels less than or
  624.   // equal to the configured number of audio channels.
  625.   let countLessThanOrEqualtoConfig =
  626.       channelCounts.filter((count) => count <= preferredAudioChannelCount);
  627.   if (countLessThanOrEqualtoConfig.length) {
  628.     return variantsByChannelCount[Math.max.apply(null,
  629.         countLessThanOrEqualtoConfig)];
  630.   }
  631.   // If all variants have more audio channels than the config, choose the
  632.   // variants with the fewest audio channels.
  633.   return variantsByChannelCount[Math.min.apply(null, channelCounts)];
  634. };
  636. /**
  637.  * Chooses streams according to the given config.
  638.  *
  639.  * @param {!Array.<shakaExtern.Stream>} streams
  640.  * @param {string} preferredLanguage
  641.  * @param {string} preferredRole
  642.  * @param {!Object=} languageMatches
  643.  * @return {!Array.<!shakaExtern.Stream>}
  644.  */
  645. shaka.util.StreamUtils.filterStreamsByLanguageAndRole = function(
  646.     streams, preferredLanguage, preferredRole, languageMatches) {
  647.   const LanguageUtils = shaka.util.LanguageUtils;
  648.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  650.   /** @type {!Array.<!shakaExtern.Stream>} */
  651.   let chosen = streams;
  653.   // Start with the set of primary streams.
  654.   /** @type {!Array.<!shakaExtern.Stream>} */
  655.   let primary = streams.filter(function(stream) {
  656.     return stream.primary;
  657.   });
  659.   if (primary.length) {
  660.     chosen = primary;
  661.   }
  663.   // Now reduce the set to one language.  This covers both arbitrary language
  664.   // choice and the reduction of the "primary" stream set to one language.
  665.   let firstLanguage = chosen.length ? chosen[0].language : '';
  666.   chosen = chosen.filter(function(stream) {
  667.     return stream.language == firstLanguage;
  668.   });
  670.   // Now search for matches based on language preference.  If any language match
  671.   // is found, it overrides the selection above.  Favor exact matches, then base
  672.   // matches, finally different subtags.  Execute in reverse order so the later
  673.   // steps override the previous ones.
  674.   if (preferredLanguage) {
  675.     let pref = LanguageUtils.normalize(preferredLanguage);
  676.     [LanguageUtils.MatchType.OTHER_SUB_LANGUAGE_OKAY,
  677.      LanguageUtils.MatchType.BASE_LANGUAGE_OKAY,
  678.      LanguageUtils.MatchType.EXACT]
  679.         .forEach(function(matchType) {
  680.           let betterLangMatchFound = false;
  681.           streams.forEach(function(stream) {
  682.             let lang = LanguageUtils.normalize(stream.language);
  683.             if (LanguageUtils.match(matchType, pref, lang)) {
  684.               if (betterLangMatchFound) {
  685.                 chosen.push(stream);
  686.               } else {
  687.                 chosen = [stream];
  688.                 betterLangMatchFound = true;
  689.               }
  690.               if (languageMatches) {
  691.                 languageMatches[ContentType.TEXT] = true;
  692.               }
  693.             }
  694.           }); // forEach(stream)
  695.         }); // forEach(matchType)
  696.   } // if (preferredLanguage)
  698.   // Now refine the choice based on role preference.
  699.   if (preferredRole) {
  700.     let roleMatches = shaka.util.StreamUtils.filterTextStreamsByRole_(
  701.         chosen, preferredRole);
  702.     if (roleMatches.length) {
  703.       return roleMatches;
  704.     } else {
  705.       shaka.log.warning('No exact match for the text role could be found.');
  706.     }
  707.   } else {
  708.     // Prefer text streams with no roles, if they exist.
  709.     let noRoleMatches = chosen.filter(function(stream) {
  710.       return stream.roles.length == 0;
  711.     });
  712.     if (noRoleMatches.length) {
  713.       return noRoleMatches;
  714.     }
  715.   }
  717.   // Either there was no role preference, or it could not be satisfied.
  718.   // Choose an arbitrary role, if there are any, and filter out any other roles.
  719.   // This ensures we never adapt between roles.
  721.   let allRoles = chosen.map(function(stream) {
  722.     return stream.roles;
  723.   }).reduce(shaka.util.Functional.collapseArrays, []);
  725.   if (!allRoles.length) {
  726.     return chosen;
  727.   }
  728.   return shaka.util.StreamUtils.filterTextStreamsByRole_(chosen, allRoles[0]);
  729. };
  732. /**
  733.  * Filter Variants by role.
  734.  *
  735.  * @param {!Array.<shakaExtern.Variant>} variants
  736.  * @param {string} preferredRole
  737.  * @return {!Array.<shakaExtern.Variant>}
  738.  * @private
  739.  */
  740. shaka.util.StreamUtils.filterVariantsByRole_ =
  741.     function(variants, preferredRole) {
  742.   return variants.filter(function(variant) {
  743.     return (variant.audio && variant.audio.roles.indexOf(preferredRole) >= 0) ||
  744.            (variant.video && variant.video.roles.indexOf(preferredRole) >= 0);
  745.   });
  746. };
  749. /**
  750.  * Filter text Streams by role.
  751.  *
  752.  * @param {!Array.<shakaExtern.Stream>} textStreams
  753.  * @param {string} preferredRole
  754.  * @return {!Array.<shakaExtern.Stream>}
  755.  * @private
  756.  */
  757. shaka.util.StreamUtils.filterTextStreamsByRole_ =
  758.     function(textStreams, preferredRole) {
  759.   return textStreams.filter(function(stream) {
  760.     return stream.roles.indexOf(preferredRole) >= 0;
  761.   });
  762. };
  765. /**
  766.  * Finds a Variant with given audio and video streams.
  767.  * Returns null if no such Variant was found.
  768.  *
  769.  * @param {?shakaExtern.Stream} audio
  770.  * @param {?shakaExtern.Stream} video
  771.  * @param {!Array.<!shakaExtern.Variant>} variants
  772.  * @return {?shakaExtern.Variant}
  773.  */
  774. shaka.util.StreamUtils.getVariantByStreams = function(audio, video, variants) {
  775.   if (audio) {
  776.     goog.asserts.assert(
  777.         shaka.util.StreamUtils.isAudio(audio),
  778.         'Audio streams must have the audio type.');
  779.   }
  781.   if (video) {
  782.     goog.asserts.assert(
  783.         shaka.util.StreamUtils.isVideo(video),
  784.         'Video streams must have the video type.');
  785.   }
  787.   for (let i = 0; i < variants.length; i++) {
  788.     if (variants[i].audio == audio && variants[i].video == video) {
  789.       return variants[i];
  790.     }
  791.   }
  793.   return null;
  794. };
  797. /**
  798.  * Finds a Variant with the given video and audio streams, by stream ID.
  799.  * Returns null if no such Variant was found.
  800.  *
  801.  * @param {?number} audioId
  802.  * @param {?number} videoId
  803.  * @param {!Array.<shakaExtern.Variant>} variants
  804.  * @return {?shakaExtern.Variant}
  805.  */
  806. shaka.util.StreamUtils.getVariantByStreamIds = function(
  807.     audioId, videoId, variants) {
  808.   function matchesId(id, stream) {
  809.     if (id == null) {
  810.       return stream == null;
  811.     } else {
  812.       return stream.id == id;
  813.     }
  814.   }
  816.   for (let i = 0; i < variants.length; i++) {
  817.     if (matchesId(audioId, variants[i].audio) &&
  818.         matchesId(videoId, variants[i].video)) {
  819.       return variants[i];
  820.     }
  821.   }
  823.   return null;
  824. };
  827. /**
  828.  * Gets the index of the Period that contains the given time.
  829.  * @param {shakaExtern.Manifest} manifest
  830.  * @param {number} time The time in seconds from the start of the presentation.
  831.  * @return {number}
  832.  */
  833. shaka.util.StreamUtils.findPeriodContainingTime = function(manifest, time) {
  834.   let threshold = shaka.util.ManifestParserUtils.GAP_OVERLAP_TOLERANCE_SECONDS;
  835.   for (let i = manifest.periods.length - 1; i > 0; --i) {
  836.     let period = manifest.periods[i];
  837.     // The last segment may end right before the end of the Period because of
  838.     // rounding issues.
  839.     if (time + threshold >= period.startTime) {
  840.       return i;
  841.     }
  842.   }
  843.   return 0;
  844. };
  847. /**
  848.  * @param {shakaExtern.Manifest} manifest
  849.  * @param {shakaExtern.Stream} stream
  850.  * @return {number} The index of the Period which contains |stream|, or -1 if
  851.  *   no Period contains |stream|.
  852.  */
  853. shaka.util.StreamUtils.findPeriodContainingStream = function(manifest, stream) {
  854.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  855.   for (let periodIdx = 0; periodIdx < manifest.periods.length; ++periodIdx) {
  856.     let period = manifest.periods[periodIdx];
  857.     if (stream.type == ContentType.TEXT) {
  858.       for (let j = 0; j < period.textStreams.length; ++j) {
  859.         let textStream = period.textStreams[j];
  860.         if (textStream == stream) {
  861.           return periodIdx;
  862.         }
  863.       }
  864.     } else {
  865.       for (let j = 0; j < period.variants.length; ++j) {
  866.         let variant = period.variants[j];
  867.         if (variant.audio == stream || variant.video == stream ||
  868.             (variant.video && variant.video.trickModeVideo == stream)) {
  869.           return periodIdx;
  870.         }
  871.       }
  872.     }
  873.   }
  874.   return -1;
  875. };
  878. /**
  879.  * @param {shakaExtern.Manifest} manifest
  880.  * @param {shakaExtern.Variant} variant
  881.  * @return {number} The index of the Period which contains |stream|, or -1 if
  882.  *   no Period contains |stream|.
  883.  */
  884. shaka.util.StreamUtils.findPeriodContainingVariant =
  885.     function(manifest, variant) {
  886.   for (let periodIdx = 0; periodIdx < manifest.periods.length; ++periodIdx) {
  887.     let period = manifest.periods[periodIdx];
  888.     for (let j = 0; j < period.variants.length; ++j) {
  889.       if (period.variants[j] == variant) {
  890.         return periodIdx;
  891.       }
  892.     }
  893.   }
  894.   return -1;
  895. };
  898. /**
  899.  * Gets the rebuffering goal from the manifest and configuration.
  900.  *
  901.  * @param {shakaExtern.Manifest} manifest
  902.  * @param {shakaExtern.StreamingConfiguration} config
  903.  * @param {number} scaleFactor
  904.  *
  905.  * @return {number}
  906.  */
  907. shaka.util.StreamUtils.getRebufferingGoal = function(
  908.     manifest, config, scaleFactor) {
  909.   return scaleFactor *
  910.          Math.max(manifest.minBufferTime || 0, config.rebufferingGoal);
  911. };
  914. /**
  915.  * Checks if the given stream is an audio stream.
  916.  *
  917.  * @param {shakaExtern.Stream} stream
  918.  * @return {boolean}
  919.  */
  920. shaka.util.StreamUtils.isAudio = function(stream) {
  921.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  922.   return stream.type == ContentType.AUDIO;
  923. };
  926. /**
  927.  * Checks if the given stream is a video stream.
  928.  *
  929.  * @param {shakaExtern.Stream} stream
  930.  * @return {boolean}
  931.  */
  932. shaka.util.StreamUtils.isVideo = function(stream) {
  933.   const ContentType = shaka.util.ManifestParserUtils.ContentType;
  934.   return stream.type == ContentType.VIDEO;
  935. };