shaka-player 4.9.8 → 4.9.10

package/externs/shaka/player.js

@@ -589,8 +589,8 @@ shaka.extern.MetadataFrame;
  *   The presentation time (in seconds) that the region should end.
  * @property {string} id
  *   Specifies an identifier for this instance of the region.
- * @property {Elment} eventElement
- *   <b>DEPRECATED</b>: Use eventElement instead.
+ * @property {Element} eventElement
+ *   <b>DEPRECATED</b>: Use eventNode instead.
  *   The XML element that defines the Event.
  * @property {?shaka.extern.xml.Node} eventNode
  *   The XML element that defines the Event.

package/lib/cea/mp4_cea_parser.js

@@ -164,53 +164,62 @@ shaka.cea.Mp4CeaParser = class {
     /** @type {!Array<!shaka.extern.ICeaParser.CaptionPacket>} **/
     const captionPackets = [];
 
-    // Fields that are found in MOOF boxes
-    let defaultSampleDuration = this.defaultSampleDuration_;
-    let defaultSampleSize = this.defaultSampleSize_;
     let moofOffset = 0;
-    /** @type {!Array<shaka.util.ParsedTRUNBox>} */
-    let parsedTRUNs = [];
-    let baseMediaDecodeTime = null;
-    let timescale = shaka.cea.CeaUtils.DEFAULT_TIMESCALE_VALUE;
+
+    /** @type {!Array<!shaka.cea.Mp4CeaParser.ParsedTRAF>} */
+    let parsedTRAFs = [];
 
     new Mp4Parser()
         .box('moof', (box) => {
           moofOffset = box.start;
-          // trun box parsing is reset on each moof.
-          parsedTRUNs = [];
+          // traf box parsing is reset on each moof.
+          parsedTRAFs = [];
+          Mp4Parser.children(box);
+        })
+        .box('traf', (box) => {
+          parsedTRAFs.push({
+            baseMediaDecodeTime: null,
+            defaultSampleDuration: this.defaultSampleDuration_,
+            defaultSampleSize: this.defaultSampleSize_,
+            parsedTRUNs: [],
+            timescale: shaka.cea.CeaUtils.DEFAULT_TIMESCALE_VALUE,
+          });
           Mp4Parser.children(box);
         })
-        .box('traf', Mp4Parser.children)
         .fullBox('trun', (box) => {
           goog.asserts.assert(
-              box.version != null && box.flags!=null,
+              box.version != null && box.flags != null,
               'TRUN is a full box and should have a valid version & flags.');
 
+          const lastTRAF = parsedTRAFs[parsedTRAFs.length - 1];
+
           const parsedTRUN = shaka.util.Mp4BoxParsers.parseTRUN(
               box.reader, box.version, box.flags);
-          parsedTRUNs.push(parsedTRUN);
+          lastTRAF.parsedTRUNs.push(parsedTRUN);
         })
         .fullBox('tfhd', (box) => {
           goog.asserts.assert(
               box.flags != null,
               'TFHD is a full box and should have valid flags.');
 
+          const lastTRAF = parsedTRAFs[parsedTRAFs.length - 1];
+
           const parsedTFHD = shaka.util.Mp4BoxParsers.parseTFHD(
               box.reader, box.flags);
 
           // If specified, defaultSampleDuration and defaultSampleSize
           // override the ones specified in the TREX box
-          defaultSampleDuration = parsedTFHD.defaultSampleDuration ||
+          lastTRAF.defaultSampleDuration = parsedTFHD.defaultSampleDuration ||
               this.defaultSampleDuration_;
 
-          defaultSampleSize = parsedTFHD.defaultSampleSize ||
+          lastTRAF.defaultSampleSize = parsedTFHD.defaultSampleSize ||
               this.defaultSampleSize_;
 
           const trackId = parsedTFHD.trackId;
 
           // Get the timescale from the track Id
           if (this.trackIdToTimescale_.has(trackId)) {
-            timescale = this.trackIdToTimescale_.get(trackId);
+            lastTRAF.timescale = this.trackIdToTimescale_.get(trackId);
           }
         })
         .fullBox('tfdt', (box) => {
@@ -218,27 +227,37 @@ shaka.cea.Mp4CeaParser = class {
               box.version != null,
               'TFDT is a full box and should have a valid version.');
 
+          const lastTRAF = parsedTRAFs[parsedTRAFs.length - 1];
+
           const parsedTFDT = shaka.util.Mp4BoxParsers.parseTFDTInaccurate(
               box.reader, box.version);
 
-          baseMediaDecodeTime = parsedTFDT.baseMediaDecodeTime;
+          lastTRAF.baseMediaDecodeTime = parsedTFDT.baseMediaDecodeTime;
         })
         .box('mdat', (box) => {
-          if (baseMediaDecodeTime === null) {
-            // This field should have been populated by the Base Media Decode
-            // Time in the tfdt box.
-            shaka.log.alwaysWarn(
-                'Unable to find base media decode time for CEA captions!');
-            throw new shaka.util.Error(
-                shaka.util.Error.Severity.CRITICAL,
-                shaka.util.Error.Category.TEXT,
-                shaka.util.Error.Code.INVALID_MP4_CEA);
-          }
-
           const offset = moofOffset - box.start - 8;
-          this.parseMdat_(box.reader, baseMediaDecodeTime, timescale,
-              defaultSampleDuration, defaultSampleSize, offset, parsedTRUNs,
-              captionPackets);
+          const initialPosition = box.reader.getPosition();
+          for (const parsedTRAF of parsedTRAFs) {
+            if (parsedTRAF.baseMediaDecodeTime === null) {
+              // This field should have been populated by the Base Media Decode
+              // Time in the tfdt box.
+              shaka.log.alwaysWarn(
+                  'Unable to find base media decode time for CEA captions!');
+              throw new shaka.util.Error(
+                  shaka.util.Error.Severity.CRITICAL,
+                  shaka.util.Error.Category.TEXT,
+                  shaka.util.Error.Code.INVALID_MP4_CEA);
+            }
+            box.reader.seek(initialPosition);
+            this.parseMdat_(box.reader,
+                parsedTRAF.baseMediaDecodeTime,
+                parsedTRAF.timescale,
+                parsedTRAF.defaultSampleDuration,
+                parsedTRAF.defaultSampleSize,
+                offset,
+                parsedTRAF.parsedTRUNs,
+                captionPackets);
+          }
         })
         .parse(mediaSegment, /* partialOkay= */ false);
 
@@ -315,7 +334,7 @@ shaka.cea.Mp4CeaParser = class {
           timeOffset = sampleData[sampleIndex].sampleCompositionTimeOffset || 0;
         }
 
-        const pts = (time + timeOffset)/timescale;
+        const pts = (time + timeOffset) / timescale;
         for (const packet of this.seiProcessor_
             .process(reader.readBytes(naluSize - naluHeaderSize))) {
           captionPackets.push({
@@ -384,5 +403,22 @@ shaka.cea.Mp4CeaParser.CodecBitstreamMap_ = {
   'dvhe': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
 };
 
+/**
+ * @typedef {{
+ *    baseMediaDecodeTime: ?number,
+ *    defaultSampleDuration: number,
+ *    defaultSampleSize: number,
+ *    parsedTRUNs: !Array<shaka.util.ParsedTRUNBox>,
+ *    timescale: number
+ * }}
+ *
+ * @property {?number} baseMediaDecodeTime
+ * @property {number} defaultSampleDuration
+ * @property {number} defaultSampleSize
+ * @property {!Array<shaka.util.ParsedTRUNBox>} parsedTRUNs
+ * @property {?number} timescale
+ */
+shaka.cea.Mp4CeaParser.ParsedTRAF;
+
 shaka.media.ClosedCaptionParser.registerParser('video/mp4',
     () => new shaka.cea.Mp4CeaParser());

package/lib/dash/mpd_utils.js

@@ -166,9 +166,9 @@ shaka.dash.MpdUtils = class {
 
       if (!d) {
         shaka.log.warning(
-            '"S" element must have a duration:',
-            'ignoring the remaining "S" elements.', timePoint);
-        return timeline;
+            '"S" element must have a duration: ignoring this element.',
+            timePoint);
+        continue;
       }
 
       let startTime = t != null ? t : lastEndTime;

package/lib/hls/hls_parser.js

@@ -466,7 +466,7 @@ shaka.hls.HlsParser = class {
     }
 
     const {segments, bandwidth} = this.createSegments_(
-        playlist, stream, mediaSequenceToStartTime, mediaVariables,
+        playlist, mediaSequenceToStartTime, mediaVariables,
         streamInfo.getUris, streamInfo.type);
     if (bandwidth) {
       stream.bandwidth = bandwidth;
@@ -2302,6 +2302,13 @@ shaka.hls.HlsParser = class {
       /** @type {!shaka.hls.Playlist} */
       const playlist = this.manifestTextParser_.parsePlaylist(response.data);
 
+      if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MANIFEST,
+            shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
+      }
+
       /** @type {!Array.<!shaka.hls.Tag>} */
       const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
           'EXT-X-DEFINE');
@@ -2319,24 +2326,32 @@ shaka.hls.HlsParser = class {
           this.config_.hls.disableCodecGuessing) ||
           (this.needsClosedCaptionsDetection_ && type == ContentType.VIDEO &&
           !this.config_.hls.disableClosedCaptionsDetection)) {
-        this.needsClosedCaptionsDetection_ = false;
-
-        const basicInfo = await this.getMediaPlaylistBasicInfo_(
-            playlist, getUris, mediaVariables);
-
-        goog.asserts.assert(
-            type === basicInfo.type, 'Media types should match!');
-
-        if (basicInfo.closedCaptions.size && (!closedCaptions ||
-            closedCaptions.size != basicInfo.closedCaptions.size)) {
-          closedCaptions = basicInfo.closedCaptions;
-          closedCaptionsUpdated = true;
+        let canRequestBasicInfo = playlist.segments.length > 0;
+        if (canRequestBasicInfo) {
+          const segment = playlist.segments[0];
+          if (shaka.hls.Utils.getFirstTagWithName(segment.tags, 'EXT-X-GAP')) {
+            canRequestBasicInfo = false;
+          }
         }
+        if (canRequestBasicInfo) {
+          this.needsClosedCaptionsDetection_ = false;
+          const basicInfo = await this.getMediaPlaylistBasicInfo_(
+              playlist, getUris, mediaVariables);
+
+          goog.asserts.assert(
+              type === basicInfo.type, 'Media types should match!');
+
+          if (basicInfo.closedCaptions.size && (!closedCaptions ||
+              closedCaptions.size != basicInfo.closedCaptions.size)) {
+            closedCaptions = basicInfo.closedCaptions;
+            closedCaptionsUpdated = true;
+          }
 
-        if (!this.codecInfoInManifest_ &&
-            this.config_.hls.disableCodecGuessing) {
-          mimeType = basicInfo.mimeType;
-          codecs = basicInfo.codecs;
+          if (!this.codecInfoInManifest_ &&
+              this.config_.hls.disableCodecGuessing) {
+            mimeType = basicInfo.mimeType;
+            codecs = basicInfo.codecs;
+          }
         }
       }
 
@@ -2623,15 +2638,6 @@ shaka.hls.HlsParser = class {
       getUris, responseUri, codecs, type, languageValue, primary, name,
       channelsCount, closedCaptions, characteristics, forced, sampleRate,
       spatialAudio, mimeType = undefined) {
-    if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
-      // EXT-X-MEDIA and EXT-X-IMAGE-STREAM-INF tags should point to media
-      // playlists.
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
-    }
-
     goog.asserts.assert(playlist.segments != null,
         'Media playlist should have segments!');
 
@@ -2641,9 +2647,14 @@ shaka.hls.HlsParser = class {
       this.determineLastTargetDuration_(playlist);
     }
 
+    const mediaSequenceToStartTime = this.isLive_() ?
+        this.mediaSequenceToStartTimeByType_.get(type) : new Map();
+
+    const {segments, bandwidth} = this.createSegments_(
+        playlist, mediaSequenceToStartTime, variables, getUris, type);
+
     if (!mimeType) {
-      mimeType = await this.guessMimeType_(type, codecs, playlist,
-          variables, getUris);
+      mimeType = await this.guessMimeType_(type, codecs, segments);
     }
 
     const {drmInfos, keyIds, encrypted, aesEncrypted} =
@@ -2663,16 +2674,10 @@ shaka.hls.HlsParser = class {
     stream.drmInfos = drmInfos;
     stream.keyIds = keyIds;
     stream.mimeType = mimeType;
-    this.setFullTypeForStream_(stream);
-
-    const mediaSequenceToStartTime = this.isLive_() ?
-        this.mediaSequenceToStartTimeByType_.get(type) : new Map();
-
-    const {segments, bandwidth} = this.createSegments_(
-        playlist, stream, mediaSequenceToStartTime, variables, getUris, type);
     if (bandwidth) {
       stream.bandwidth = bandwidth;
     }
+    this.setFullTypeForStream_(stream);
 
     // This new calculation is necessary for Low Latency streams.
     if (this.isLive_()) {
@@ -3303,7 +3308,7 @@ shaka.hls.HlsParser = class {
    * @param {number} startTime
    * @param {!Map.<string, string>} variables
    * @param {!shaka.hls.Playlist} playlist
-   * @param {shaka.extern.Stream} stream
+   * @param {string} type
    * @param {function():!Array.<string>} getUris
    * @param {shaka.extern.aesKey=} aesKey
    * @return {shaka.media.SegmentReference}
@@ -3311,7 +3316,7 @@ shaka.hls.HlsParser = class {
    */
   createSegmentReference_(
       initSegmentReference, previousReference, hlsSegment, startTime,
-      variables, playlist, stream, getUris, aesKey) {
+      variables, playlist, type, getUris, aesKey) {
     const tags = hlsSegment.tags;
     const extinfTag =
         shaka.hls.Utils.getFirstTagWithName(tags, 'EXTINF');
@@ -3368,8 +3373,8 @@ shaka.hls.HlsParser = class {
     let isPreloadSegment = false;
 
     if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
-      const byterangeOptimizationSupport = (stream.mimeType == 'video/mp4' ||
-          stream.mimeType == 'audio/mp4') && window.ReadableStream &&
+      const byterangeOptimizationSupport =
+          initSegmentReference && window.ReadableStream &&
           this.config_.hls.allowLowLatencyByteRangeOptimization;
 
       let partialSyncTime = syncTime;
@@ -3528,7 +3533,7 @@ shaka.hls.HlsParser = class {
 
     let tilesLayout = '';
     let tileDuration = null;
-    if (stream.type == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
+    if (type == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
       // By default in HLS the tilesLayout is 1x1
       tilesLayout = '1x1';
       const tilesTag =
@@ -3622,7 +3627,6 @@ shaka.hls.HlsParser = class {
    * playlist.
    *
    * @param {!shaka.hls.Playlist} playlist
-   * @param {shaka.extern.Stream} stream
    * @param {!Map.<number, number>} mediaSequenceToStartTime
    * @param {!Map.<string, string>} variables
    * @param {function():!Array.<string>} getUris
@@ -3631,7 +3635,7 @@ shaka.hls.HlsParser = class {
    *          bandwidth: (number|undefined)}}
    * @private
    */
-  createSegments_(playlist, stream, mediaSequenceToStartTime, variables,
+  createSegments_(playlist, mediaSequenceToStartTime, variables,
       getUris, type) {
     /** @type {Array.<!shaka.hls.Segment>} */
     const hlsSegments = playlist.segments;
@@ -3723,7 +3727,7 @@ shaka.hls.HlsParser = class {
           startTime,
           variables,
           playlist,
-          stream,
+          type,
           getUris,
           aesKey);
 
@@ -3922,34 +3926,37 @@ shaka.hls.HlsParser = class {
   }
 
   /**
-   * Attempts to guess stream's mime type based on content type, URI, and
-   * contents of the playlist.
+   * Attempts to guess stream's mime type.
    *
    * @param {string} contentType
    * @param {string} codecs
-   * @param {!shaka.hls.Playlist} playlist
-   * @param {!Map.<string, string>} variables
-   * @param {function():!Array.<string>} getUris
+   * @param {!Array.<!shaka.media.SegmentReference>} segments
    * @return {!Promise.<string>}
    * @private
    */
-  async guessMimeType_(contentType, codecs, playlist, variables, getUris) {
+  async guessMimeType_(contentType, codecs, segments) {
     const HlsParser = shaka.hls.HlsParser;
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
     // If you wait long enough, requesting the first segment can fail
     // because it has fallen off the left edge of DVR, so to be safer,
     // let's request the middle segment.
-    goog.asserts.assert(playlist.segments.length,
-        'Playlist should have segments!');
-    const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
+    goog.asserts.assert(segments.length, 'Should have segments!');
+    let segmentIndex = Math.trunc((segments.length - 1) / 2);
+    let segment = segments[segmentIndex];
+    while (segment.status == shaka.media.SegmentReference.Status.MISSING &&
+        segmentIndex < segments.length) {
+      segmentIndex ++;
+      segment = segments[segmentIndex];
+    }
 
-    const middleSegmentUris = shaka.hls.Utils.constructSegmentUris(
-        getUris(),
-        playlist.segments[middleSegmentIdx].verbatimSegmentUri,
-        variables);
+    if (segment.status == shaka.media.SegmentReference.Status.MISSING) {
+      return this.guessMimeTypeFallback_(contentType);
+    }
+
+    const segmentUris = segment.getUris();
 
-    const parsedUri = new goog.Uri(middleSegmentUris[0]);
+    const parsedUri = new goog.Uri(segmentUris[0]);
     const extension = parsedUri.getPath().split('.').pop();
     const map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
 
@@ -3974,7 +3981,7 @@ shaka.hls.HlsParser = class {
     let contentMimeType;
     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
     const headRequest = shaka.net.NetworkingEngine.makeRequest(
-        middleSegmentUris, this.config_.retryParameters);
+        segmentUris, this.config_.retryParameters);
     try {
       headRequest.method = 'HEAD';
       const response = await this.makeNetworkRequest_(
@@ -3995,7 +4002,7 @@ shaka.hls.HlsParser = class {
 
     if (contentMimeType) {
       // Split the MIME type in case the server sent additional parameters.
-      return contentMimeType.split(';')[0];
+      return contentMimeType.toLowerCase().split(';')[0];
     }
 
     return this.guessMimeTypeFallback_(contentType);

package/lib/hls/manifest_text_parser.js

@@ -312,4 +312,5 @@ shaka.hls.ManifestTextParser.SEGMENT_TAGS = [
   'EXT-X-KEY',
   'EXT-X-DATERANGE',
   'EXT-X-MAP',
+  'EXT-X-GAP',
 ];

package/lib/media/preload_manager.js

@@ -664,7 +664,7 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
           return shaka.media.StreamingEngine.dispatchFetch(
               reference, stream, streamDataCallback || null,
               this.config_.streaming.retryParameters, this.networkingEngine_);
-        });
+        }, /* reverse= */ false);
     this.segmentPrefetchById_.set(stream.id, prefetch);
 
     // Start prefetching a bit.

package/lib/media/segment_index.js

@@ -444,12 +444,17 @@ shaka.media.SegmentIndex = class {
     let index = this.find(time);
     if (index == null) {
       return null;
-    } else {
+    }
+
+    const ref = this.get(index);
+
+    // Adjust index to point to previous or next index (if reversed), so first
+    // next() call will traverse in proper direction.
+    if (!reverse) {
       index--;
+    } else {
+      index++;
     }
-    // +1 so we can get the element we'll eventually point to so we can see if
-    // we need to use a partial segment index.
-    const ref = this.get(index + 1);
 
     let partialSegmentIndex = -1;
     if (ref && ref.hasPartialSegments()) {
@@ -471,7 +476,11 @@ shaka.media.SegmentIndex = class {
           }
           // Call to next() should move the partial segment, not the full
           // segment.
-          index++;
+          if (reverse) {
+            index--;
+          } else {
+            index++;
+          }
           partialSegmentIndex = i - 1;
           break;
         }

package/lib/media/segment_prefetch.js

@@ -9,6 +9,7 @@ goog.provide('shaka.media.SegmentPrefetch');
 goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.media.InitSegmentReference');
+goog.require('shaka.media.SegmentIterator');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.Uint8ArrayUtils');
@@ -25,17 +26,15 @@ shaka.media.SegmentPrefetch = class {
    * @param {number} prefetchLimit
    * @param {shaka.extern.Stream} stream
    * @param {shaka.media.SegmentPrefetch.FetchDispatcher} fetchDispatcher
+   * @param {boolean} reverse
    */
-  constructor(prefetchLimit, stream, fetchDispatcher) {
+  constructor(prefetchLimit, stream, fetchDispatcher, reverse) {
     /** @private {number} */
     this.prefetchLimit_ = prefetchLimit;
 
     /** @private {shaka.extern.Stream} */
     this.stream_ = stream;
 
-    /** @private {number} */
-    this.prefetchPosTime_ = 0;
-
     /** @private {shaka.media.SegmentPrefetch.FetchDispatcher} */
     this.fetchDispatcher_ = fetchDispatcher;
 
@@ -52,6 +51,12 @@ shaka.media.SegmentPrefetch = class {
      *        !shaka.media.SegmentPrefetchOperation>}
      */
     this.initSegmentPrefetchMap_ = new Map();
+
+    /** @private {?shaka.media.SegmentIterator} */
+    this.iterator_ = null;
+
+    /** @private {boolean} */
+    this.reverse_ = reverse;
   }
 
   /**
@@ -64,13 +69,6 @@ shaka.media.SegmentPrefetch = class {
     }
   }
 
-  /**
-   * @return {number}
-   */
-  getLastKnownPosition() {
-    return this.prefetchPosTime_;
-  }
-
   /**
    * Fetch next segments ahead of current time.
    *
@@ -87,21 +85,22 @@ shaka.media.SegmentPrefetch = class {
       shaka.log.debug(logPrefix, 'missing segmentIndex');
       return;
     }
-    const maxTime = Math.max(currTime, this.prefetchPosTime_);
-    const iterator = this.stream_.segmentIndex.getIteratorForTime(
-        maxTime, /* allowNonIndepedent= */ true);
-    if (!iterator) {
+    if (!this.iterator_) {
+      this.iterator_ = this.stream_.segmentIndex.getIteratorForTime(
+          currTime, /* allowNonIndepedent= */ true, this.reverse_);
+    }
+    if (!this.iterator_) {
+      shaka.log.debug(logPrefix, 'missing iterator');
       return;
     }
-    let reference = iterator.next().value;
     if (skipFirst) {
-      reference = iterator.next().value;
-    }
-    if (!reference) {
-      return;
+      this.iterator_.next();
     }
-    while (this.segmentPrefetchMap_.size < this.prefetchLimit_ &&
-            reference != null) {
+    while (this.segmentPrefetchMap_.size < this.prefetchLimit_) {
+      const reference = this.iterator_.next().value;
+      if (!reference) {
+        break;
+      }
       // By default doesn't prefech preload partial segments when using
       // byterange
       let prefetchAllowed = true;
@@ -121,12 +120,10 @@ shaka.media.SegmentPrefetch = class {
         segmentPrefetchOperation.dispatchFetch(reference, this.stream_);
         this.segmentPrefetchMap_.set(reference, segmentPrefetchOperation);
       }
-      this.prefetchPosTime_ = reference.startTime;
       if (this.stream_.fastSwitching && reference.isPartial() &&
           reference.isLastPartial()) {
         break;
       }
-      reference = iterator.next().value;
     }
     this.clearInitSegments_();
   }
@@ -226,6 +223,11 @@ shaka.media.SegmentPrefetch = class {
     }
   }
 
+  /** */
+  resetPosition() {
+    this.iterator_ = null;
+  }
+
   /**
    * Clear all segment data.
    * @public
@@ -233,9 +235,9 @@ shaka.media.SegmentPrefetch = class {
   clearAll() {
     this.clearMap_(this.segmentPrefetchMap_);
     this.clearMap_(this.initSegmentPrefetchMap_);
+    this.resetPosition();
     const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
     shaka.log.debug(logPrefix, 'cleared all');
-    this.prefetchPosTime_ = 0;
   }
 
   /**
@@ -262,6 +264,16 @@ shaka.media.SegmentPrefetch = class {
     }
   }
 
+  /**
+   * @param {boolean} reverse
+   */
+  setReverse(reverse) {
+    this.reverse_ = reverse;
+    if (this.iterator_) {
+      this.iterator_.setReverse(reverse);
+    }
+  }
+
   /**
    * Remove all init segments that don't have associated segments in
    * the segment prefetch map.

package/lib/media/segment_utils.js

@@ -140,7 +140,7 @@ shaka.media.SegmentUtils = class {
     const SegmentUtils = shaka.media.SegmentUtils;
 
     const audioCodecs = [];
-    const videoCodecs = [];
+    let videoCodecs = [];
 
     let hasAudio = false;
     let hasVideo = false;
@@ -360,6 +360,13 @@ shaka.media.SegmentUtils = class {
         })
 
         .box('colr', (box) => {
+          videoCodecs = videoCodecs.map((codec) => {
+            if (codec.startsWith('av01.')) {
+              return shaka.util.Mp4BoxParsers.updateAV1CodecWithCOLRBox(
+                  codec, box.reader);
+            }
+            return codec;
+          });
           const {videoRange, colorGamut} =
               shaka.util.Mp4BoxParsers.parseCOLR(box.reader);
           realVideoRange = videoRange;