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.   var 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.   var tracksChanged = false;
  82.   period.variants.forEach(function(variant) {
  83.     var 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 {!Object.<string, shakaExtern.Stream>} activeStreams
  101.  * @param {shakaExtern.Period} period
  102.  */
  103. shaka.util.StreamUtils.filterNewPeriod = function(
  104.     drmEngine, activeStreams, period) {
  105.   var StreamUtils = shaka.util.StreamUtils;
  106.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  108.   var activeVideo = activeStreams[ContentType.VIDEO];
  109.   var activeAudio = activeStreams[ContentType.AUDIO];
  111.   // Filter variants
  112.   for (var i = 0; i < period.variants.length; ++i) {
  113.     var variant = period.variants[i];
  114.     if (!StreamUtils.variantIsCompatible_(
  115.         variant, drmEngine, activeAudio, activeVideo)) {
  116.       shaka.log.debug('Dropping Variant (not compatible with key system, ' +
  117.                       'platform, or active Variant)', variant);
  118.       period.variants.splice(i, 1);
  119.       --i;
  120.       continue;
  121.     }
  122.   }
  124.   // Filter text streams
  125.   for (var i = 0; i < period.textStreams.length; ++i) {
  126.     var stream = period.textStreams[i];
  127.     var fullMimeType = shaka.util.MimeUtils.getFullType(
  128.         stream.mimeType, stream.codecs);
  129.     if (!shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
  130.       shaka.log.debug('Dropping text stream. Is not supported by the ' +
  131.                       'platform.', stream);
  132.       period.textStreams.splice(i, 1);
  133.       --i;
  134.     }
  135.   }
  136. };
  139. /**
  140.  * Checks if a stream is compatible with the key system, platform,
  141.  * and active stream.
  142.  *
  143.  * @param {?shakaExtern.Stream} stream
  144.  * @param {shaka.media.DrmEngine} drmEngine
  145.  * @param {?shakaExtern.Stream} activeStream
  146.  * @return {boolean}
  147.  * @private
  148.  */
  149. shaka.util.StreamUtils.streamIsCompatible_ =
  150.     function(stream, drmEngine, activeStream) {
  151.   if (!stream) return true;
  153.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  154.   goog.asserts.assert(stream.type != ContentType.TEXT,
  155.       'Should not be called on a text stream!');
  157.   var drmSupportedMimeTypes = null;
  158.   if (drmEngine && drmEngine.initialized()) {
  159.     drmSupportedMimeTypes = drmEngine.getSupportedTypes();
  160.   }
  162.   // Check if stream can be played by the platform
  163.   var fullMimeType = shaka.util.MimeUtils.getFullType(
  164.       stream.mimeType, stream.codecs);
  166.   if (!shaka.media.MediaSourceEngine.isStreamSupported(stream))
  167.     return false;
  169.   // Check if stream can be handled by the key system.
  170.   // There's no need to check that the stream is supported by the
  171.   // chosen key system since the caller has already verified that.
  172.   if (drmSupportedMimeTypes && stream.encrypted &&
  173.       drmSupportedMimeTypes.indexOf(fullMimeType) < 0) {
  174.     return false;
  175.   }
  177.   // Lastly, check if active stream can switch to the stream
  178.   // Basic mime types and basic codecs need to match.
  179.   // For example, we can't adapt between WebM and MP4,
  180.   // nor can we adapt between mp4a.* to ec-3.
  181.   // We can switch between text types on the fly,
  182.   // so don't run this check on text.
  183.   if (activeStream) {
  184.     if (stream.mimeType != activeStream.mimeType ||
  185.         stream.codecs.split('.')[0] != activeStream.codecs.split('.')[0]) {
  186.       return false;
  187.     }
  188.   }
  190.   return true;
  191. };
  194. /**
  195.  * Checks if a variant is compatible with the key system, platform,
  196.  * and active stream.
  197.  *
  198.  * @param {!shakaExtern.Variant} variant
  199.  * @param {shaka.media.DrmEngine} drmEngine
  200.  * @param {shakaExtern.Stream} activeAudio
  201.  * @param {shakaExtern.Stream} activeVideo
  202.  * @return {boolean}
  203.  * @private
  204.  */
  205. shaka.util.StreamUtils.variantIsCompatible_ =
  206.     function(variant, drmEngine, activeAudio, activeVideo) {
  207.   var StreamUtils = shaka.util.StreamUtils;
  208.   if (drmEngine && drmEngine.initialized()) {
  209.     if (!drmEngine.isSupportedByKeySystem(variant)) return false;
  210.   }
  212.   return StreamUtils.streamIsCompatible_(variant.audio,
  213.                                          drmEngine,
  214.                                          activeAudio) &&
  215.          StreamUtils.streamIsCompatible_(variant.video, drmEngine, activeVideo);
  216. };
  219. /**
  220.  * Gets an array of Track objects for the given Period
  221.  *
  222.  * @param {shakaExtern.Period} period
  223.  * @param {?number} activeAudioId
  224.  * @param {?number} activeVideoId
  225.  * @return {!Array.<shakaExtern.Track>}
  226.  */
  227. shaka.util.StreamUtils.getVariantTracks =
  228.     function(period, activeAudioId, activeVideoId) {
  229.   var StreamUtils = shaka.util.StreamUtils;
  230.   var variants = StreamUtils.getPlayableVariants(period.variants);
  231.   var label = null;
  232.   var tracks = variants.map(function(variant) {
  233.     var isActive;
  234.     if (variant.video && variant.audio) {
  235.       isActive = activeVideoId == variant.video.id &&
  236.                  activeAudioId == variant.audio.id;
  237.     } else {
  238.       isActive = (variant.video && activeVideoId == variant.video.id) ||
  239.                  (variant.audio && activeAudioId == variant.audio.id);
  240.     }
  241.     var codecs = '';
  242.     if (variant.video) codecs += variant.video.codecs;
  243.     if (variant.audio) {
  244.       if (codecs != '') codecs += ', ';
  245.       codecs += variant.audio.codecs;
  246.       label = variant.audio.label;
  247.     }
  249.     var audioCodec = variant.audio ? variant.audio.codecs : null;
  250.     var videoCodec = variant.video ? variant.video.codecs : null;
  251.     var mimeType = null;
  252.     if (variant.video) mimeType = variant.video.mimeType;
  253.     else if (variant.audio) mimeType = variant.audio.mimeType;
  255.     var kind = null;
  256.     if (variant.audio) kind = variant.audio.kind;
  257.     else if (variant.video) kind = variant.video.kind;
  259.     var audioRoles = variant.audio ? variant.audio.roles : [];
  260.     var videoRoles = variant.video ? variant.video.roles : [];
  261.     var roles = shaka.util.ArrayUtils.removeDuplicates(
  262.         audioRoles.concat(videoRoles));
  263.     return {
  264.       id: variant.id,
  265.       active: isActive,
  266.       type: 'variant',
  267.       bandwidth: variant.bandwidth,
  268.       language: variant.language,
  269.       label: label,
  270.       kind: kind || null,
  271.       width: variant.video ? variant.video.width : null,
  272.       height: variant.video ? variant.video.height : null,
  273.       frameRate: variant.video ? variant.video.frameRate : undefined,
  274.       mimeType: mimeType,
  275.       codecs: codecs,
  276.       audioCodec: audioCodec,
  277.       videoCodec: videoCodec,
  278.       primary: variant.primary,
  279.       roles: roles,
  280.       videoId: variant.video ? variant.video.id : null,
  281.       audioId: variant.audio ? variant.audio.id : null,
  282.       channelsCount: variant.audio ? variant.audio.channelsCount : null,
  283.       audioBandwidth: (variant.audio && variant.audio.bandwidth) ?
  284.                        variant.audio.bandwidth : null,
  285.       videoBandwidth: (variant.video && variant.video.bandwidth) ?
  286.                        variant.video.bandwidth : null
  287.     };
  288.   });
  290.   return tracks;
  291. };
  294. /**
  295.  * Gets an array of text Track objects for the given Period.
  296.  *
  297.  * @param {shakaExtern.Period} period
  298.  * @param {?number} activeStreamId
  299.  * @return {!Array.<shakaExtern.Track>}
  300.  */
  301. shaka.util.StreamUtils.getTextTracks = function(period, activeStreamId) {
  302.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  303.   return period.textStreams.map(function(stream) {
  304.     return {
  305.       id: stream.id,
  306.       active: activeStreamId == stream.id,
  307.       type: ContentType.TEXT,
  308.       language: stream.language,
  309.       label: stream.label,
  310.       kind: stream.kind,
  311.       mimeType: stream.mimeType,
  312.       codecs: stream.codecs || null,
  313.       audioCodec: null,
  314.       videoCodec: null,
  315.       primary: stream.primary,
  316.       roles: stream.roles,
  317.       channelsCount: null,
  318.       audioBandwidth: null,
  319.       videoBandwidth: null
  320.     };
  321.   });
  322. };
  325. /**
  326.  * Find the Variant for the given track.
  327.  *
  328.  * @param {shakaExtern.Period} period
  329.  * @param {shakaExtern.Track} track
  330.  * @return {?shakaExtern.Variant}
  331.  */
  332. shaka.util.StreamUtils.findVariantForTrack = function(period, track) {
  333.   for (var i = 0; i < period.variants.length; i++) {
  334.     if (period.variants[i].id == track.id)
  335.       return period.variants[i];
  336.   }
  337.   return null;
  338. };
  341. /**
  342.  * Find the text stream for the given track.
  343.  *
  344.  * @param {shakaExtern.Period} period
  345.  * @param {shakaExtern.Track} track
  346.  * @return {?shakaExtern.Stream}
  347.  */
  348. shaka.util.StreamUtils.findTextStreamForTrack = function(period, track) {
  349.   for (var i = 0; i < period.textStreams.length; i++) {
  350.     if (period.textStreams[i].id == track.id)
  351.       return period.textStreams[i];
  352.   }
  353.   return null;
  354. };
  357. /**
  358.  * Determines if the given variant is playable.
  359.  * @param {!shakaExtern.Variant} variant
  360.  * @return {boolean}
  361.  */
  362. shaka.util.StreamUtils.isPlayable = function(variant) {
  363.   return variant.allowedByApplication && variant.allowedByKeySystem;
  364. };
  367. /**
  368.  * Filters out not playable variants.
  369.  * @param {!Array.<!shakaExtern.Variant>} variants
  370.  * @return {!Array.<!shakaExtern.Variant>}
  371.  */
  372. shaka.util.StreamUtils.getPlayableVariants = function(variants) {
  373.   return variants.filter(function(variant) {
  374.     return shaka.util.StreamUtils.isPlayable(variant);
  375.   });
  376. };
  379. /**
  380.  * Chooses variants according to the given config.
  381.  *
  382.  * @param {shakaExtern.Period} period
  383.  * @param {string} preferredLanguage
  384.  * @param {string} preferredRole
  385.  * @param {!Object=} opt_languageMatches
  386.  * @return {!Array.<!shakaExtern.Variant>}
  387.  */
  388. shaka.util.StreamUtils.filterVariantsByLanguageAndRole = function(
  389.     period, preferredLanguage, preferredRole, opt_languageMatches) {
  390.   var LanguageUtils = shaka.util.LanguageUtils;
  391.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  392.   var variants = shaka.util.StreamUtils.getPlayableVariants(period.variants);
  394.   // Start with the set of primary variants.
  395.   /** @type {!Array.<!shakaExtern.Variant>} */
  396.   var chosen = variants.filter(function(variant) {
  397.     return variant.primary;
  398.   });
  400.   // If there were no primary variants, go back to all variants.
  401.   if (!chosen.length) {
  402.     chosen = variants;
  403.   }
  405.   // Now reduce the set to one language.  This covers both arbitrary language
  406.   // choice and the reduction of the "primary" variant set to one language.
  407.   var firstLanguage = chosen.length ? chosen[0].language : '';
  408.   chosen = chosen.filter(function(variant) {
  409.     return variant.language == firstLanguage;
  410.   });
  412.   // Now search for matches based on language preference.  If any language match
  413.   // is found, it overrides the selection above.  Favor exact matches, then base
  414.   // matches, finally different subtags.  Execute in reverse order so the later
  415.   // steps override the previous ones.
  416.   if (preferredLanguage) {
  417.     var pref = LanguageUtils.normalize(preferredLanguage);
  418.     [LanguageUtils.MatchType.OTHER_SUB_LANGUAGE_OKAY,
  419.      LanguageUtils.MatchType.BASE_LANGUAGE_OKAY,
  420.      LanguageUtils.MatchType.EXACT]
  421.         .forEach(function(matchType) {
  422.           var betterLangMatchFound = false;
  423.           variants.forEach(function(variant) {
  424.             pref = LanguageUtils.normalize(pref);
  425.             var lang = LanguageUtils.normalize(variant.language);
  426.             if (LanguageUtils.match(matchType, pref, lang)) {
  427.               if (betterLangMatchFound) {
  428.                 chosen.push(variant);
  429.               } else {
  430.                 chosen = [variant];
  431.                 betterLangMatchFound = true;
  432.               }
  433.               if (opt_languageMatches) {
  434.                 opt_languageMatches[ContentType.AUDIO] = true;
  435.               }
  436.             }
  437.           }); // forEach(variant)
  438.         }); // forEach(matchType)
  439.   } // if (preferredLanguage)
  441.   // Now refine the choice based on role preference.
  442.   if (preferredRole) {
  443.     var roleMatches = shaka.util.StreamUtils.filterVariantsByRole_(
  444.         chosen, preferredRole);
  445.     if (roleMatches.length) {
  446.       return roleMatches;
  447.     } else {
  448.       shaka.log.warning('No exact match for the variant role could be found.');
  449.     }
  450.   }
  452.   // Either there was no role preference, or it could not be satisfied.
  453.   // Choose an arbitrary role, if there are any, and filter out any other roles.
  454.   // This ensures we never adapt between roles.
  455.   var allRoles = chosen.map(function(variant) {
  456.     var audioRoles = variant.audio ? variant.audio.roles : [];
  457.     var videoRoles = variant.video ? variant.video.roles : [];
  458.     return audioRoles.concat(videoRoles);
  459.   }).reduce(shaka.util.Functional.collapseArrays, []);
  461.   if (!allRoles.length) {
  462.     return chosen;
  463.   }
  464.   return shaka.util.StreamUtils.filterVariantsByRole_(chosen, allRoles[0]);
  465. };
  468. /**
  469.  * Chooses text streams according to the given config.
  470.  *
  471.  * @param {shakaExtern.Period} period
  472.  * @param {string} preferredLanguage
  473.  * @param {string} preferredRole
  474.  * @param {!Object=} opt_languageMatches
  475.  * @return {!Array.<!shakaExtern.Stream>}
  476.  */
  477. shaka.util.StreamUtils.filterTextStreamsByLanguageAndRole = function(
  478.     period, preferredLanguage, preferredRole, opt_languageMatches) {
  479.   var LanguageUtils = shaka.util.LanguageUtils;
  480.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  481.   var streams = period.textStreams;
  483.   // Start with the set of primary streams.
  484.   /** @type {!Array.<!shakaExtern.Stream>} */
  485.   var chosen = streams.filter(function(stream) {
  486.     return stream.primary;
  487.   });
  489.   // If there were no primary streams, go back to all streams.
  490.   if (!chosen.length) {
  491.     chosen = streams;
  492.   }
  494.   // Now reduce the set to one language.  This covers both arbitrary language
  495.   // choice and the reduction of the "primary" stream set to one language.
  496.   var firstLanguage = chosen.length ? chosen[0].language : '';
  497.   chosen = chosen.filter(function(stream) {
  498.     return stream.language == firstLanguage;
  499.   });
  501.   // Now search for matches based on language preference.  If any language match
  502.   // is found, it overrides the selection above.  Favor exact matches, then base
  503.   // matches, finally different subtags.  Execute in reverse order so the later
  504.   // steps override the previous ones.
  505.   if (preferredLanguage) {
  506.     var pref = LanguageUtils.normalize(preferredLanguage);
  507.     [LanguageUtils.MatchType.OTHER_SUB_LANGUAGE_OKAY,
  508.      LanguageUtils.MatchType.BASE_LANGUAGE_OKAY,
  509.      LanguageUtils.MatchType.EXACT]
  510.         .forEach(function(matchType) {
  511.           var betterLangMatchFound = false;
  512.           streams.forEach(function(stream) {
  513.             var lang = LanguageUtils.normalize(stream.language);
  514.             if (LanguageUtils.match(matchType, pref, lang)) {
  515.               if (betterLangMatchFound) {
  516.                 chosen.push(stream);
  517.               } else {
  518.                 chosen = [stream];
  519.                 betterLangMatchFound = true;
  520.               }
  521.               if (opt_languageMatches)
  522.                 opt_languageMatches[ContentType.TEXT] = true;
  523.             }
  524.           }); // forEach(stream)
  525.         }); // forEach(matchType)
  526.   } // if (preferredLanguage)
  528.   // Now refine the choice based on role preference.
  529.   if (preferredRole) {
  530.     var roleMatches = shaka.util.StreamUtils.filterTextStreamsByRole_(
  531.         chosen, preferredRole);
  532.     if (roleMatches.length) {
  533.       return roleMatches;
  534.     } else {
  535.       shaka.log.warning('No exact match for the text role could be found.');
  536.     }
  537.   }
  539.   // Either there was no role preference, or it could not be satisfied.
  540.   // Choose an arbitrary role, if there are any, and filter out any other roles.
  541.   // This ensures we never adapt between roles.
  543.   var allRoles = chosen.map(function(stream) {
  544.     return stream.roles;
  545.   }).reduce(shaka.util.Functional.collapseArrays, []);
  547.   if (!allRoles.length) {
  548.     return chosen;
  549.   }
  550.   return shaka.util.StreamUtils.filterTextStreamsByRole_(chosen, allRoles[0]);
  551. };
  554. /**
  555.  * Filter Variants by role.
  556.  *
  557.  * @param {!Array.<shakaExtern.Variant>} variants
  558.  * @param {string} preferredRole
  559.  * @return {!Array.<shakaExtern.Variant>}
  560.  * @private
  561.  */
  562. shaka.util.StreamUtils.filterVariantsByRole_ =
  563.     function(variants, preferredRole) {
  564.   return variants.filter(function(variant) {
  565.     return (variant.audio && variant.audio.roles.indexOf(preferredRole) >= 0) ||
  566.            (variant.video && variant.video.roles.indexOf(preferredRole) >= 0);
  567.   });
  568. };
  571. /**
  572.  * Filter text Streams by role.
  573.  *
  574.  * @param {!Array.<shakaExtern.Stream>} textStreams
  575.  * @param {string} preferredRole
  576.  * @return {!Array.<shakaExtern.Stream>}
  577.  * @private
  578.  */
  579. shaka.util.StreamUtils.filterTextStreamsByRole_ =
  580.     function(textStreams, preferredRole) {
  581.   return textStreams.filter(function(stream) {
  582.     return stream.roles.indexOf(preferredRole) >= 0;
  583.   });
  584. };
  587. /**
  588.  * Finds a Variant with given audio and video streams.
  589.  * Returns null if none was found.
  590.  *
  591.  * @param {?shakaExtern.Stream} audio
  592.  * @param {?shakaExtern.Stream} video
  593.  * @param {!Array.<!shakaExtern.Variant>} variants
  594.  * @return {?shakaExtern.Variant}
  595.  */
  596. shaka.util.StreamUtils.getVariantByStreams = function(audio, video, variants) {
  597.   for (var i = 0; i < variants.length; i++) {
  598.     if (variants[i].audio == audio && variants[i].video == video)
  599.       return variants[i];
  600.   }
  602.   return null;
  603. };
  606. /**
  607.  * Finds a Variant with the given video and audio streams, by stream ID.
  608.  * Returns null if none were found.
  609.  *
  610.  * @param {?number} audioId
  611.  * @param {?number} videoId
  612.  * @param {!Array.<shakaExtern.Variant>} variants
  613.  * @return {?shakaExtern.Variant}
  614.  */
  615. shaka.util.StreamUtils.getVariantByStreamIds = function(
  616.     audioId, videoId, variants) {
  617.   function matchesId(id, stream) {
  618.     if (id == null)
  619.       return stream == null;
  620.     else
  621.       return stream.id == id;
  622.   }
  624.   for (var i = 0; i < variants.length; i++) {
  625.     if (matchesId(audioId, variants[i].audio) &&
  626.         matchesId(videoId, variants[i].video)) {
  627.       return variants[i];
  628.     }
  629.   }
  631.   return null;
  632. };
  635. /**
  636.  * Gets the index of the Period that contains the given time.
  637.  * @param {shakaExtern.Manifest} manifest
  638.  * @param {number} time The time in seconds from the start of the presentation.
  639.  * @return {number}
  640.  */
  641. shaka.util.StreamUtils.findPeriodContainingTime = function(manifest, time) {
  642.   var threshold = shaka.util.ManifestParserUtils.GAP_OVERLAP_TOLERANCE_SECONDS;
  643.   for (var i = manifest.periods.length - 1; i > 0; --i) {
  644.     var period = manifest.periods[i];
  645.     // The last segment may end right before the end of the Period because of
  646.     // rounding issues.
  647.     if (time + threshold >= period.startTime)
  648.       return i;
  649.   }
  650.   return 0;
  651. };
  654. /**
  655.  * @param {shakaExtern.Manifest} manifest
  656.  * @param {shakaExtern.Stream} stream
  657.  * @return {number} The index of the Period which contains |stream|, or -1 if
  658.  *   no Period contains |stream|.
  659.  */
  660. shaka.util.StreamUtils.findPeriodContainingStream = function(manifest, stream) {
  661.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  662.   for (var periodIdx = 0; periodIdx < manifest.periods.length; ++periodIdx) {
  663.     var period = manifest.periods[periodIdx];
  664.     if (stream.type == ContentType.TEXT) {
  665.       for (var j = 0; j < period.textStreams.length; ++j) {
  666.         var textStream = period.textStreams[j];
  667.         if (textStream == stream)
  668.           return periodIdx;
  669.       }
  670.     } else {
  671.       for (var j = 0; j < period.variants.length; ++j) {
  672.         var variant = period.variants[j];
  673.         if (variant.audio == stream || variant.video == stream ||
  674.             (variant.video && variant.video.trickModeVideo == stream)) {
  675.           return periodIdx;
  676.         }
  677.       }
  678.     }
  679.   }
  680.   return -1;
  681. };
  684. /**
  685.  * @param {shakaExtern.Manifest} manifest
  686.  * @param {shakaExtern.Variant} variant
  687.  * @return {number} The index of the Period which contains |stream|, or -1 if
  688.  *   no Period contains |stream|.
  689.  */
  690. shaka.util.StreamUtils.findPeriodContainingVariant =
  691.     function(manifest, variant) {
  692.   for (var periodIdx = 0; periodIdx < manifest.periods.length; ++periodIdx) {
  693.     var period = manifest.periods[periodIdx];
  694.     for (var j = 0; j < period.variants.length; ++j) {
  695.       if (period.variants[j] == variant) {
  696.         return periodIdx;
  697.       }
  698.     }
  699.   }
  700.   return -1;
  701. };
  704. /**
  705.  * Gets the rebuffering goal from the manifest and configuration.
  706.  *
  707.  * @param {shakaExtern.Manifest} manifest
  708.  * @param {shakaExtern.StreamingConfiguration} config
  709.  * @param {number} scaleFactor
  710.  *
  711.  * @return {number}
  712.  */
  713. shaka.util.StreamUtils.getRebufferingGoal = function(
  714.     manifest, config, scaleFactor) {
  715.   return scaleFactor *
  716.          Math.max(manifest.minBufferTime || 0, config.rebufferingGoal);
  717. };