shaka-player 4.12.8 → 4.13.0

package/lib/media/preference_based_criteria.js

@@ -0,0 +1,333 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.media.PreferenceBasedCriteria');
+
+goog.require('shaka.config.CodecSwitchingStrategy');
+goog.require('shaka.log');
+goog.require('shaka.media.AdaptationSet');
+goog.require('shaka.media.AdaptationSetCriteria');
+goog.require('shaka.media.Capabilities');
+goog.require('shaka.util.LanguageUtils');
+
+
+/**
+ * @implements {shaka.media.AdaptationSetCriteria}
+ * @final
+ */
+shaka.media.PreferenceBasedCriteria = class {
+  /** */
+  constructor() {
+    /** @private {?shaka.media.AdaptationSetCriteria.Configuration} */
+    this.config_ = null;
+  }
+
+  /**
+   * @override
+   */
+  configure(config) {
+    this.config_ = config;
+  }
+
+  /**
+   * @override
+   */
+  create(variants) {
+    const Class = shaka.media.PreferenceBasedCriteria;
+
+    let current = [];
+
+    const byLanguage = Class.filterByLanguage_(variants, this.config_.language);
+    const byPrimary = variants.filter((variant) => variant.primary);
+
+    if (byLanguage.length) {
+      current = byLanguage;
+    } else if (byPrimary.length) {
+      current = byPrimary;
+    } else {
+      current = variants;
+    }
+
+    // Now refine the choice based on role preference.  Even the empty string
+    // works here, and will match variants without any roles.
+    const byRole = Class.filterVariantsByRole_(current, this.config_.role);
+    if (byRole.length) {
+      current = byRole;
+    } else {
+      shaka.log.warning('No exact match for variant role could be found.');
+    }
+
+    if (this.config_.videoLayout) {
+      const byVideoLayout = Class.filterVariantsByVideoLayout_(
+          current, this.config_.videoLayout);
+      if (byVideoLayout.length) {
+        current = byVideoLayout;
+      } else {
+        shaka.log.warning(
+            'No exact match for the video layout could be found.');
+      }
+    }
+
+    if (this.config_.hdrLevel) {
+      const byHdrLevel = Class.filterVariantsByHDRLevel_(
+          current, this.config_.hdrLevel);
+      if (byHdrLevel.length) {
+        current = byHdrLevel;
+      } else {
+        shaka.log.warning(
+            'No exact match for the hdr level could be found.');
+      }
+    }
+
+    if (this.config_.channelCount) {
+      const byChannel = Class.filterVariantsByAudioChannelCount_(
+          current, this.config_.channelCount);
+      if (byChannel.length) {
+        current = byChannel;
+      } else {
+        shaka.log.warning(
+            'No exact match for the channel count could be found.');
+      }
+    }
+
+    if (this.config_.audioLabel) {
+      const byLabel = Class.filterVariantsByAudioLabel_(
+          current, this.config_.audioLabel);
+      if (byLabel.length) {
+        current = byLabel;
+      } else {
+        shaka.log.warning('No exact match for audio label could be found.');
+      }
+    }
+
+    if (this.config_.videoLabel) {
+      const byLabel = Class.filterVariantsByVideoLabel_(
+          current, this.config_.videoLabel);
+      if (byLabel.length) {
+        current = byLabel;
+      } else {
+        shaka.log.warning('No exact match for video label could be found.');
+      }
+    }
+
+    const bySpatialAudio = Class.filterVariantsBySpatialAudio_(
+        current, this.config_.spatialAudio);
+    if (bySpatialAudio.length) {
+      current = bySpatialAudio;
+    } else {
+      shaka.log.warning('No exact match for spatial audio could be found.');
+    }
+
+    if (this.config_.audioCodec) {
+      const byAudioCodec = Class.filterVariantsByAudioCodec_(
+          current, this.config_.audioCodec);
+      if (byAudioCodec.length) {
+        current = byAudioCodec;
+      } else {
+        shaka.log.warning('No exact match for audio codec could be found.');
+      }
+    }
+
+    const supportsSmoothCodecTransitions =
+      this.config_.codecSwitchingStrategy ==
+      shaka.config.CodecSwitchingStrategy.SMOOTH &&
+        shaka.media.Capabilities.isChangeTypeSupported();
+
+    return new shaka.media.AdaptationSet(current[0], current,
+        !supportsSmoothCodecTransitions);
+  }
+
+  /**
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {string} preferredLanguage
+   * @return {!Array<shaka.extern.Variant>}
+   * @private
+   */
+  static filterByLanguage_(variants, preferredLanguage) {
+    const LanguageUtils = shaka.util.LanguageUtils;
+
+    /** @type {string} */
+    const preferredLocale = LanguageUtils.normalize(preferredLanguage);
+
+    /** @type {?string} */
+    const closestLocale = LanguageUtils.findClosestLocale(
+        preferredLocale,
+        variants.map((variant) => LanguageUtils.getLocaleForVariant(variant)));
+
+    // There were no locales close to what we preferred.
+    if (!closestLocale) {
+      return [];
+    }
+
+    // Find the variants that use the closest variant.
+    return variants.filter((variant) => {
+      return closestLocale == LanguageUtils.getLocaleForVariant(variant);
+    });
+  }
+
+  /**
+   * Filter Variants by role.
+   *
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {string} preferredRole
+   * @return {!Array<shaka.extern.Variant>}
+   * @private
+   */
+  static filterVariantsByRole_(variants, preferredRole) {
+    return variants.filter((variant) => {
+      if (!variant.audio) {
+        return false;
+      }
+
+      if (preferredRole) {
+        return variant.audio.roles.includes(preferredRole);
+      } else {
+        return variant.audio.roles.length == 0;
+      }
+    });
+  }
+
+  /**
+   * Filter Variants by audio label.
+   *
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {string} preferredLabel
+   * @return {!Array<shaka.extern.Variant>}
+   * @private
+   */
+  static filterVariantsByAudioLabel_(variants, preferredLabel) {
+    return variants.filter((variant) => {
+      if (!variant.audio || !variant.audio.label) {
+        return false;
+      }
+
+      const label1 = variant.audio.label.toLowerCase();
+      const label2 = preferredLabel.toLowerCase();
+      return label1 == label2;
+    });
+  }
+
+  /**
+   * Filter Variants by video label.
+   *
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {string} preferredLabel
+   * @return {!Array<shaka.extern.Variant>}
+   * @private
+   */
+  static filterVariantsByVideoLabel_(variants, preferredLabel) {
+    return variants.filter((variant) => {
+      if (!variant.video || !variant.video.label) {
+        return false;
+      }
+
+      const label1 = variant.video.label.toLowerCase();
+      const label2 = preferredLabel.toLowerCase();
+      return label1 == label2;
+    });
+  }
+
+  /**
+   * Filter Variants by channelCount.
+   *
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {number} channelCount
+   * @return {!Array<shaka.extern.Variant>}
+   * @private
+   */
+  static filterVariantsByAudioChannelCount_(variants, channelCount) {
+    return variants.filter((variant) => {
+      if (variant.audio && variant.audio.channelsCount &&
+          variant.audio.channelsCount != channelCount) {
+        return false;
+      }
+      return true;
+    });
+  }
+
+  /**
+   * Filters variants according to the given hdr level config.
+   *
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {string} hdrLevel
+   * @private
+   */
+  static filterVariantsByHDRLevel_(variants, hdrLevel) {
+    if (hdrLevel == 'AUTO') {
+      // Auto detect the ideal HDR level.
+      if (window.matchMedia('(color-gamut: p3)').matches) {
+        const someHLG = variants.some((variant) => {
+          if (variant.video && variant.video.hdr &&
+              variant.video.hdr == 'HLG') {
+            return true;
+          }
+          return false;
+        });
+        hdrLevel = someHLG ? 'HLG' : 'PQ';
+      } else {
+        hdrLevel = 'SDR';
+      }
+    }
+    return variants.filter((variant) => {
+      if (variant.video && variant.video.hdr && variant.video.hdr != hdrLevel) {
+        return false;
+      }
+      return true;
+    });
+  }
+
+
+  /**
+   * Filters variants according to the given video layout config.
+   *
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {string} videoLayout
+   * @private
+   */
+  static filterVariantsByVideoLayout_(variants, videoLayout) {
+    return variants.filter((variant) => {
+      if (variant.video && variant.video.videoLayout &&
+          variant.video.videoLayout != videoLayout) {
+        return false;
+      }
+      return true;
+    });
+  }
+
+
+  /**
+   * Filters variants according to the given spatial audio config.
+   *
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {boolean} spatialAudio
+   * @private
+   */
+  static filterVariantsBySpatialAudio_(variants, spatialAudio) {
+    return variants.filter((variant) => {
+      if (variant.audio && variant.audio.spatialAudio != spatialAudio) {
+        return false;
+      }
+      return true;
+    });
+  }
+
+
+  /**
+   * Filters variants according to the given audio codec.
+   *
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {string} audioCodec
+   * @private
+   */
+  static filterVariantsByAudioCodec_(variants, audioCodec) {
+    return variants.filter((variant) => {
+      if (variant.audio && variant.audio.codecs != audioCodec) {
+        return false;
+      }
+      return true;
+    });
+  }
+};

package/lib/media/preload_manager.js

@@ -7,28 +7,26 @@
 goog.provide('shaka.media.PreloadManager');
 
 goog.require('goog.asserts');
+goog.require('shaka.drm.DrmEngine');
 goog.require('shaka.log');
-goog.require('shaka.util.Error');
+goog.require('shaka.media.AdaptationSetCriteria');
 goog.require('shaka.media.ManifestFilterer');
 goog.require('shaka.media.ManifestParser');
-goog.require('shaka.util.PublicPromise');
-goog.require('shaka.media.PreferenceBasedCriteria');
-goog.require('shaka.util.Stats');
-goog.require('shaka.media.SegmentPrefetch');
-goog.require('shaka.util.IDestroyable');
-goog.require('shaka.net.NetworkingEngine');
-goog.require('shaka.media.AdaptationSetCriteria');
-goog.require('shaka.media.DrmEngine');
-goog.require('shaka.media.RegionTimeline');
 goog.require('shaka.media.QualityObserver');
-goog.require('shaka.util.StreamUtils');
-goog.require('shaka.media.StreamingEngine');
+goog.require('shaka.media.RegionTimeline');
 goog.require('shaka.media.SegmentPrefetch');
+goog.require('shaka.media.StreamingEngine');
+goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.ConfigUtils');
+goog.require('shaka.util.Error');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.FakeEventTarget');
+goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.ObjectUtils');
 goog.require('shaka.util.PlayerConfiguration');
+goog.require('shaka.util.PublicPromise');
+goog.require('shaka.util.Stats');
+goog.require('shaka.util.StreamUtils');
 
 /**
  * @implements {shaka.util.IDestroyable}
@@ -69,7 +67,7 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
     /** @private {number} */
     this.startTimeOfDrm_ = 0;
 
-    /** @private {function():!shaka.media.DrmEngine} */
+    /** @private {function():!shaka.drm.DrmEngine} */
     this.createDrmEngine_ = typedPlayerInterface.createDrmEngine;
 
     /** @private {!shaka.media.ManifestFilterer} */
@@ -100,7 +98,7 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
     /** @private {boolean} */
     this.regionTimelineEntrusted_ = false;
 
-    /** @private {?shaka.media.DrmEngine} */
+    /** @private {?shaka.drm.DrmEngine} */
     this.drmEngine_ = null;
 
     /** @private {boolean} */
@@ -115,7 +113,7 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
     /** @private {boolean} */
     this.abrManagerEntrusted_ = false;
 
-    /** @private {!Map.<number, shaka.media.SegmentPrefetch>} */
+    /** @private {!Map<number, shaka.media.SegmentPrefetch>} */
     this.segmentPrefetchById_ = new Map();
 
     /** @private {boolean} */
@@ -151,10 +149,10 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
     /** @private {boolean} */
     this.hasBeenAttached_ = false;
 
-    /** @private {?Array.<function()>} */
+    /** @private {?Array<function()>} */
     this.queuedOperations_ = [];
 
-    /** @private {?Array.<function()>} */
+    /** @private {?Array<function()>} */
     this.latePhaseQueuedOperations_ = [];
 
     /** @private {boolean} */
@@ -322,7 +320,7 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
   /**
    * Gets the drm engine, if it exists. Also marks that the drm engine should
    * not be destroyed if this manager is destroyed.
-   * @return {?shaka.media.DrmEngine}
+   * @return {?shaka.drm.DrmEngine}
    */
   receiveDrmEngine() {
     this.drmEngineEntrusted_ = true;
@@ -330,7 +328,7 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * @return {?shaka.media.DrmEngine}
+   * @return {?shaka.drm.DrmEngine}
    */
   getDrmEngine() {
     return this.drmEngine_;
@@ -346,7 +344,7 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
   /**
    * Gets the SegmentPrefetch objects for the initial stream ids. Also marks
    * that those objects should not be aborted if this manager is destroyed.
-   * @return {!Map.<number, shaka.media.SegmentPrefetch>}
+   * @return {!Map<number, shaka.media.SegmentPrefetch>}
    */
   receiveSegmentPrefetchesById() {
     this.segmentPrefetchEntrusted_ = true;
@@ -478,7 +476,7 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
 
   /**
    * @param {!shaka.util.FakeEvent.EventName} name
-   * @param {Map.<string, Object>=} data
+   * @param {Map<string, Object>=} data
    * @return {!shaka.util.FakeEvent}
    * @private
    */
@@ -513,6 +511,19 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
     if (!this.manifest_) {
       this.manifest_ = await this.parser_.start(
           this.assetUri_, this.manifestPlayerInterface_);
+
+      if (this.manifest_.variants.length == 1) {
+        const createSegmentIndexPromises = [];
+        const variant = this.manifest_.variants[0];
+        for (const stream of [variant.video, variant.audio]) {
+          if (stream && !stream.segmentIndex) {
+            createSegmentIndexPromises.push(stream.createSegmentIndex());
+          }
+        }
+        if (createSegmentIndexPromises.length > 0) {
+          await Promise.all(createSegmentIndexPromises);
+        }
+      }
     }
 
     this.manifestPromise_.resolve();
@@ -632,17 +643,20 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
       // Copy preferred languages from the config again, in case the config was
       // changed between construction and playback.
       this.currentAdaptationSetCriteria_ =
-          new shaka.media.PreferenceBasedCriteria(
-              this.config_.preferredAudioLanguage,
-              this.config_.preferredVariantRole,
-              this.config_.preferredAudioChannelCount,
-              this.config_.preferredVideoHdrLevel,
-              this.config_.preferSpatialAudio,
-              this.config_.preferredVideoLayout,
-              this.config_.preferredAudioLabel,
-              this.config_.preferredVideoLabel,
-              this.config_.mediaSource.codecSwitchingStrategy,
-              /* audioCodec= */ '');
+          this.config_.adaptationSetCriteriaFactory();
+      this.currentAdaptationSetCriteria_.configure({
+        language: this.config_.preferredAudioLanguage,
+        role: this.config_.preferredVariantRole,
+        channelCount: this.config_.preferredAudioChannelCount,
+        hdrLevel: this.config_.preferredVideoHdrLevel,
+        spatialAudio: this.config_.preferSpatialAudio,
+        videoLayout: this.config_.preferredVideoLayout,
+        audioLabel: this.config_.preferredAudioLabel,
+        videoLabel: this.config_.preferredVideoLabel,
+        codecSwitchingStrategy:
+            this.config_.mediaSource.codecSwitchingStrategy,
+        audioCodec: '',
+      });
     }
 
     // Make the ABR manager.
@@ -699,7 +713,9 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
     this.segmentPrefetchById_.set(stream.id, prefetch);
 
     // Start prefetching a bit.
-    await stream.createSegmentIndex();
+    if (!stream.segmentIndex) {
+      await stream.createSegmentIndex();
+    }
     const startTime = this.startTime_ || 0;
     const prefetchSegmentIterator =
         stream.segmentIndex.getIteratorForTime(startTime);
@@ -823,7 +839,7 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
  *   manifestPlayerInterface: !shaka.extern.ManifestParser.PlayerInterface,
  *   regionTimeline: !shaka.media.RegionTimeline,
  *   qualityObserver: ?shaka.media.QualityObserver,
- *   createDrmEngine: function():!shaka.media.DrmEngine,
+ *   createDrmEngine: function():!shaka.drm.DrmEngine,
  *   networkingEngine: !shaka.net.NetworkingEngine,
  *   manifestFilterer: !shaka.media.ManifestFilterer,
  *   allowPrefetch: boolean,
@@ -831,11 +847,11 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
  * }}
  *
  * @property {!shaka.extern.PlayerConfiguration} config
- * @property {!shaka.extern.ManifestParser.PlayerInterface}
- *   manifestPlayerInterface
+ * @property {!shaka.extern.ManifestParser.PlayerInterface
+ *           } manifestPlayerInterface
  * @property {!shaka.media.RegionTimeline} regionTimeline
  * @property {?shaka.media.QualityObserver} qualityObserver
- * @property {function():!shaka.media.DrmEngine} createDrmEngine
+ * @property {function():!shaka.drm.DrmEngine} createDrmEngine
  * @property {!shaka.net.NetworkingEngine} networkingEngine
  * @property {!shaka.media.ManifestFilterer} manifestFilterer
  * @property {boolean} allowPrefetch

package/lib/media/presentation_timeline.js

@@ -244,7 +244,7 @@ shaka.media.PresentationTimeline = class {
    * the segment availability window, and account for missing segment
    * information.
    *
-   * @param {!Array.<shaka.media.PresentationTimeline.TimeRange>} timeline
+   * @param {!Array<shaka.media.PresentationTimeline.TimeRange>} timeline
    * @param {number} startOffset
    * @export
    */
@@ -294,7 +294,7 @@ shaka.media.PresentationTimeline = class {
    * information.  These segments do not necessarily need to all be from the
    * same stream.
    *
-   * @param {!Array.<!shaka.media.SegmentReference>} references
+   * @param {!Array<!shaka.media.SegmentReference>} references
    * @export
    */
   notifySegments(references) {

package/lib/media/quality_observer.js

@@ -32,7 +32,7 @@ shaka.media.QualityObserver = class extends shaka.util.FakeEventTarget {
     super();
 
     /**
-     * @private {!Map.<string,!shaka.media.QualityObserver.ContentTypeState>}
+     * @private {!Map<string, !shaka.media.QualityObserver.ContentTypeState>}
      */
     this.contentTypeStates_ = new Map();
 
@@ -47,7 +47,7 @@ shaka.media.QualityObserver = class extends shaka.util.FakeEventTarget {
   }
 
   /**
-   * Get the ContenTypeState for a contentType, creating a new
+   * Get the ContentTypeState for a contentType, creating a new
    * one if necessary.
    *
    * @param {!string} contentType
@@ -301,40 +301,40 @@ shaka.media.QualityObserver = class extends shaka.util.FakeEventTarget {
 };
 
 /**
-  * @typedef {{
-  *   mediaQuality: !shaka.extern.MediaQualityInfo,
-  *   position: !number
-  * }}
-  *
-  * @description
-  * Identifies the position of a media quality change in the
-  * source buffer.
-  *
-  * @property {shaka.extern.MediaQualityInfo} !mediaQuality
-  *   The new media quality for content after position in the source buffer.
-  * @property {number} !position
-  *   A position in seconds in the source buffer
-  */
+ * @typedef {{
+ *   mediaQuality: !shaka.extern.MediaQualityInfo,
+ *   position: !number
+ * }}
+ *
+ * @description
+ * Identifies the position of a media quality change in the
+ * source buffer.
+ *
+ * @property {!shaka.extern.MediaQualityInfo} mediaQuality
+ *   The new media quality for content after position in the source buffer.
+ * @property {!number} position
+ *   A position in seconds in the source buffer
+ */
 shaka.media.QualityObserver.QualityChangePosition;
 
 /**
-  * @typedef {{
-  *  qualityChangePositions:
-  *   !Array.<shaka.media.QualityObserver.QualityChangePosition>,
-  *  currentQuality: ?shaka.extern.MediaQualityInfo,
-  *  contentType: !string
-  * }}
-  *
-  * @description
-  * Contains media quality information for a specific content type
-  * e.g. video or audio.
-  *
-  * @property {!Array.<shaka.media.QualityObserver.QualityChangePosition>}
-  * qualityChangePositions
-  *   Quality changes ordered by position ascending.
-  * @property {?shaka.media.MediaQualityInfo} currentMediaQuality
-  *   The media quality at the playhead position.
-  * @property {string} contentType
-  *   The contentType e.g. 'video' or 'audio'
-  */
+ * @typedef {{
+ *  qualityChangePositions:
+ *   !Array<shaka.media.QualityObserver.QualityChangePosition>,
+ *  currentQuality: ?shaka.extern.MediaQualityInfo,
+ *  contentType: !string
+ * }}
+ *
+ * @description
+ * Contains media quality information for a specific content type
+ * e.g. video or audio.
+ *
+ * @property {!Array<shaka.media.QualityObserver.QualityChangePosition>
+ *           } qualityChangePositions
+ *   Quality changes ordered by position ascending.
+ * @property {?shaka.media.MediaQualityInfo} currentMediaQuality
+ *   The media quality at the playhead position.
+ * @property {string} contentType
+ *   The contentType e.g. 'video' or 'audio'
+ */
 shaka.media.QualityObserver.ContentTypeState;

package/lib/media/region_observer.js

@@ -50,7 +50,7 @@ shaka.media.RegionObserver = class extends shaka.util.FakeEventTarget {
      * When the value here differs from what we calculate, it means we moved and
      * should fire an event.
      *
-     * @private {!Map.<shaka.extern.TimelineRegionInfo,
+     * @private {!Map<shaka.extern.TimelineRegionInfo,
      *                 shaka.media.RegionObserver.RelativePosition_>}
      */
     this.oldPosition_ = new Map();
@@ -65,7 +65,7 @@ shaka.media.RegionObserver = class extends shaka.util.FakeEventTarget {
      * A read-only collection of rules for what to do when we change position
      * relative to a region.
      *
-     * @private {!Iterable.<shaka.media.RegionObserver.Rule_>}
+     * @private {!Iterable<shaka.media.RegionObserver.Rule_>}
      */
     this.rules_ = [
       {

package/lib/media/region_timeline.js

@@ -27,7 +27,7 @@ shaka.media.RegionTimeline = class extends shaka.util.FakeEventTarget {
   constructor(getSeekRange) {
     super();
 
-    /** @private {!Set.<shaka.extern.TimelineRegionInfo>} */
+    /** @private {!Set<shaka.extern.TimelineRegionInfo>} */
     this.regions_ = new Set();
 
     /** @private {!function():{start: number, end: number}} */
@@ -80,7 +80,7 @@ shaka.media.RegionTimeline = class extends shaka.util.FakeEventTarget {
       // Future regions might become relevant eventually,
       // but regions that are in the past and can't ever be
       // seeked to will never come up again, and there's no
-      // reson to store or process them.
+      // reason to store or process them.
       if (region.endTime < seekRange.start) {
         this.regions_.delete(region);
         const event = new shaka.util.FakeEvent('regionremove', new Map([
@@ -123,7 +123,7 @@ shaka.media.RegionTimeline = class extends shaka.util.FakeEventTarget {
    * others to see what regions are in the timeline while not being able to
    * change the collection.
    *
-   * @return {!Iterable.<shaka.extern.TimelineRegionInfo>}
+   * @return {!Iterable<shaka.extern.TimelineRegionInfo>}
    */
   regions() {
     return this.regions_;