shaka-player 3.2.2 → 3.3.0

package/lib/dash/segment_template.js

@@ -31,7 +31,7 @@ shaka.dash.SegmentTemplate = class {
    * @param {shaka.dash.DashParser.Context} context
    * @param {shaka.dash.DashParser.RequestInitSegmentCallback}
    *   requestInitSegment
-   * @param {!Object.<string, !shaka.media.SegmentIndex>} segmentIndexMap
+   * @param {!Object.<string, !shaka.extern.Stream>} streamMap
    * @param {boolean} isUpdate True if the manifest is being updated.
    * @param {number} segmentLimit The maximum number of segments to generate for
    *   a SegmentTemplate with fixed duration.
@@ -39,8 +39,8 @@ shaka.dash.SegmentTemplate = class {
    * @return {shaka.dash.DashParser.StreamInfo}
    */
   static createStreamInfo(
-      context, requestInitSegment, segmentIndexMap, isUpdate,
-      segmentLimit, periodDurationMap) {
+      context, requestInitSegment, streamMap, isUpdate, segmentLimit,
+      periodDurationMap) {
     goog.asserts.assert(context.representation.segmentTemplate,
         'Should only be called with SegmentTemplate');
     const SegmentTemplate = shaka.dash.SegmentTemplate;
@@ -86,10 +86,14 @@ shaka.dash.SegmentTemplate = class {
       /** @type {shaka.media.SegmentIndex} */
       let segmentIndex = null;
       let id = null;
+      let stream = null;
       if (context.period.id && context.representation.id) {
         // Only check/store the index if period and representation IDs are set.
         id = context.period.id + ',' + context.representation.id;
-        segmentIndex = segmentIndexMap[id];
+        stream = streamMap[id];
+        if (stream) {
+          segmentIndex = stream.segmentIndex;
+        }
       }
 
       const references = SegmentTemplate.createFromTimeline_(
@@ -117,9 +121,6 @@ shaka.dash.SegmentTemplate = class {
             context.presentationTimeline.getSegmentAvailabilityStart());
       } else {
         segmentIndex = new shaka.media.SegmentIndex(references);
-        if (id && context.dynamic) {
-          segmentIndexMap[id] = segmentIndex;
-        }
       }
       context.presentationTimeline.notifySegments(references);
 
@@ -127,8 +128,20 @@ shaka.dash.SegmentTemplate = class {
         segmentIndex.fit(periodStart, periodEnd);
       }
 
+      if (stream && context.dynamic) {
+        stream.segmentIndex = segmentIndex;
+      }
+
       return {
-        generateSegmentIndex: () => Promise.resolve(segmentIndex),
+        generateSegmentIndex: () => {
+          // If segmentIndex is deleted, or segmentIndex's references are
+          // released by closeSegmentIndex(), we should set the value of
+          // segmentIndex again.
+          if (!segmentIndex || segmentIndex.isEmpty()) {
+            segmentIndex.merge(references);
+          }
+          return Promise.resolve(segmentIndex);
+        },
       };
     }
   }
@@ -569,8 +582,8 @@ shaka.dash.SegmentTemplate = class {
           baseUris, [filledTemplate]);
       return resolvedUris;
     };
-
-    return new shaka.media.InitSegmentReference(getUris, 0, null);
+    const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
+    return new shaka.media.InitSegmentReference(getUris, 0, null, qualityInfo);
   }
 };
 

package/lib/hls/hls_parser.js

@@ -25,6 +25,7 @@ goog.require('shaka.net.DataUriPlugin');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.CmcdManager');
 goog.require('shaka.util.DataViewReader');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.FakeEvent');
@@ -332,7 +333,8 @@ shaka.hls.HlsParser = class {
     const segments = await this.createSegments_(
         streamInfo.verbatimMediaPlaylistUri, playlist, stream.type,
         stream.mimeType, streamInfo.mediaSequenceToStartTime, mediaVariables,
-        streamInfo.discontinuityToMediaSequence);
+        streamInfo.discontinuityToMediaSequence, stream.codecs,
+        stream.bandwidth);
 
     stream.segmentIndex.mergeAndEvict(
         segments, this.presentationTimeline_.getSegmentAvailabilityStart());
@@ -763,7 +765,7 @@ shaka.hls.HlsParser = class {
       const videoRange = tag.getAttributeValue('VIDEO-RANGE');
 
       const streamInfos = await this.createStreamInfosForVariantTag_(tag,
-          resolution, frameRate);
+          resolution, frameRate, bandwidth);
 
       if (streamInfos) {
         goog.asserts.assert(streamInfos.audio.length ||
@@ -797,10 +799,11 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Tag} tag
    * @param {?string} resolution
    * @param {?string} frameRate
+   * @param {number} bandwidth
    * @return {!Promise.<?shaka.hls.HlsParser.StreamInfos>}
    * @private
    */
-  async createStreamInfosForVariantTag_(tag, resolution, frameRate) {
+  async createStreamInfosForVariantTag_(tag, resolution, frameRate, bandwidth) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     /** @type {!Array.<string>} */
     let allCodecs = this.getCodecsForVariantTag_(tag);
@@ -870,7 +873,8 @@ shaka.hls.HlsParser = class {
     let streamInfo;
     if (!ignoreStream) {
       streamInfo =
-          await this.createStreamInfoFromVariantTag_(tag, allCodecs, type);
+          await this.createStreamInfoFromVariantTag_(tag, allCodecs, type,
+              bandwidth);
     }
     if (streamInfo) {
       res[streamInfo.stream.type] = [streamInfo];
@@ -893,15 +897,12 @@ shaka.hls.HlsParser = class {
    */
   getCodecsForVariantTag_(tag) {
     // These are the default codecs to assume if none are specified.
-    // The video codec is H.264, with baseline profile and level 3.0.
-    // http://blog.pearce.org.nz/2013/11/what-does-h264avc1-codecs-parameters.html
-    // The audio codec is "low-complexity" AAC.
     const defaultCodecsArray = [];
     if (!this.config_.disableVideo) {
-      defaultCodecsArray.push('avc1.42E01E');
+      defaultCodecsArray.push(this.config_.hls.defaultVideoCodec);
     }
     if (!this.config_.disableAudio) {
-      defaultCodecsArray.push('mp4a.40.2');
+      defaultCodecsArray.push(this.config_.hls.defaultAudioCodec);
     }
     const defaultCodecs = defaultCodecsArray.join(',');
 
@@ -1290,10 +1291,11 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Tag} tag
    * @param {!Array.<string>} allCodecs
    * @param {string} type
+   * @param {number} bandwidth
    * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
-  async createStreamInfoFromVariantTag_(tag, allCodecs, type) {
+  async createStreamInfoFromVariantTag_(tag, allCodecs, type, bandwidth) {
     goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
         'Should only be called on variant tags!');
     const verbatimMediaPlaylistUri = this.variableSubstitution_(
@@ -1309,7 +1311,7 @@ shaka.hls.HlsParser = class {
         codecs, type, /* language= */ 'und', /* primary= */ false,
         /* name= */ null, /* channelcount= */ null, closedCaptions,
         /* characteristics= */ null, /* forced= */ false,
-        /* spatialAudio= */ false);
+        /* spatialAudio= */ false, bandwidth);
     if (streamInfo == null) {
       return null;
     }
@@ -1336,12 +1338,13 @@ shaka.hls.HlsParser = class {
    * @param {?string} characteristics
    * @param {boolean} forced
    * @param {boolean} spatialAudio
+   * @param {(number|undefined)} bandwidth
    * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
   async createStreamInfo_(verbatimMediaPlaylistUri, codecs, type, language,
       primary, name, channelsCount, closedCaptions, characteristics, forced,
-      spatialAudio) {
+      spatialAudio, bandwidth = undefined) {
     // TODO: Refactor, too many parameters
     let absoluteMediaPlaylistUri = shaka.hls.Utils.constructAbsoluteUri(
         this.masterPlaylistUri_, verbatimMediaPlaylistUri);
@@ -1459,7 +1462,7 @@ shaka.hls.HlsParser = class {
     try {
       segments = await this.createSegments_(verbatimMediaPlaylistUri,
           playlist, type, mimeType, mediaSequenceToStartTime, mediaVariables,
-          discontinuityToMediaSequence);
+          discontinuityToMediaSequence, codecs, bandwidth);
     } catch (error) {
       if (error.code == shaka.util.Error.Code.HLS_INTERNAL_SKIP_STREAM) {
         shaka.log.alwaysWarn('Skipping unsupported HLS stream',
@@ -1887,11 +1890,14 @@ shaka.hls.HlsParser = class {
    * @param {!Map.<number, number>} mediaSequenceToStartTime
    * @param {!Map.<string, string>} variables
    * @param {!Map.<number, number>} discontinuityToMediaSequence
+   * @param {string} codecs
+   * @param {(number|undefined)} bandwidth
    * @return {!Promise<!Array.<!shaka.media.SegmentReference>>}
    * @private
    */
   async createSegments_(verbatimMediaPlaylistUri, playlist, type, mimeType,
-      mediaSequenceToStartTime, variables, discontinuityToMediaSequence) {
+      mediaSequenceToStartTime, variables, discontinuityToMediaSequence,
+      codecs, bandwidth) {
     /** @type {Array.<!shaka.hls.Segment>} */
     const hlsSegments = playlist.segments;
     goog.asserts.assert(hlsSegments.length, 'Playlist should have segments!');
@@ -1934,7 +1940,7 @@ shaka.hls.HlsParser = class {
         this.playlistStartTime_ = await this.getStartTime_(
             verbatimMediaPlaylistUri, initSegmentRef, mimeType,
             position, /* isDiscontinuity= */ false,
-            hlsSegments[0], variables, type);
+            hlsSegments[0], variables, type, codecs, bandwidth);
       }
       firstStartTime = this.playlistStartTime_;
     }
@@ -1987,7 +1993,8 @@ shaka.hls.HlsParser = class {
         // eslint-disable-next-line no-await-in-loop
         timestampOffset = await this.getTimestampOffset_(
             discontintuitySequenceNum, verbatimMediaPlaylistUri, initSegmentRef,
-            mimeType, position, item, variables, startTime, type);
+            mimeType, position, item, variables, startTime, type, codecs,
+            bandwidth);
       }
 
       // If the stream is low latency and the user has not configured the
@@ -2041,13 +2048,16 @@ shaka.hls.HlsParser = class {
    * @param {!Map.<string, string>} variables
    * @param {number} startTime
    * @param {string} type
+   * @param {string} codecs
+   * @param {number|undefined} bandwidth
    * @return {!Promise.<number>}
    * @throws {shaka.util.Error}
    * @private
    */
   async getTimestampOffset_(discontintuitySequenceNum,
       verbatimMediaPlaylistUri, initSegmentRef,
-      mimeType, mediaSequenceNumber, segment, variables, startTime, type) {
+      mimeType, mediaSequenceNumber, segment, variables, startTime, type,
+      codecs, bandwidth) {
     let timestampOffset = 0;
     if (this.discontinuityToTso_.has(discontintuitySequenceNum)) {
       timestampOffset =
@@ -2056,7 +2066,7 @@ shaka.hls.HlsParser = class {
       const mediaStartTime = await this.getStartTime_(
           verbatimMediaPlaylistUri, initSegmentRef, mimeType,
           mediaSequenceNumber, /* isDiscontinuity= */ true, segment,
-          variables, type);
+          variables, type, codecs, bandwidth);
       timestampOffset = startTime - mediaStartTime;
       shaka.log.v1('Segment timestampOffset =', timestampOffset);
       this.discontinuityToTso_.set(
@@ -2070,10 +2080,14 @@ shaka.hls.HlsParser = class {
    * segment if we have to.
    *
    * @param {!shaka.media.AnySegmentReference} reference
+   * @param {string} type
+   * @param {string} mimeType
+   * @param {string} codecs
+   * @param {number|undefined} bandwidth
    * @return {!Promise.<shaka.extern.Response>}
    * @private
    */
-  async fetchStartOfSegment_(reference) {
+  async fetchStartOfSegment_(reference, type, mimeType, codecs, bandwidth) {
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
     // Create two requests:
@@ -2087,6 +2101,20 @@ shaka.hls.HlsParser = class {
         reference.endByte,
         this.config_.retryParameters);
 
+    // We can only add partial CMCD data here because the stream
+    // and manifest objects are still being created
+    this.playerInterface_.modifySegmentRequest(
+        fullRequest,
+        {
+          type: type,
+          init: reference instanceof shaka.media.InitSegmentReference,
+          duration: reference.endTime - reference.startTime,
+          mimeType: mimeType,
+          codecs: codecs,
+          bandwidth: bandwidth,
+        },
+    );
+
     if (this.config_.hls.useFullSegmentsForStartTime) {
       return this.makeNetworkRequest_(fullRequest, requestType);
     }
@@ -2097,6 +2125,18 @@ shaka.hls.HlsParser = class {
         reference.startByte + shaka.hls.HlsParser.START_OF_SEGMENT_SIZE_ - 1,
         this.config_.retryParameters);
 
+    this.playerInterface_.modifySegmentRequest(
+        partialRequest,
+        {
+          type: type,
+          init: reference instanceof shaka.media.InitSegmentReference,
+          duration: reference.endTime - reference.startTime,
+          mimeType: mimeType,
+          codecs: codecs,
+          bandwidth: bandwidth,
+        },
+    );
+
     // TODO(vaage): The need to do fall back requests is not likely to be unique
     //    to here. It would be nice if the fallback(s) could be included into
     //    the same abortable operation as the original request.
@@ -2144,12 +2184,14 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Segment} segment
    * @param {!Map.<string, string>} variables
    * @param {string} type
+   * @param {string} codecs
+   * @param {number|undefined} bandwidth
    * @return {!Promise.<number>}
    * @private
    */
   async getStartTime_(
       verbatimMediaPlaylistUri, initSegmentRef, mimeType, mediaSequenceNumber,
-      isDiscontinuity, segment, variables, type) {
+      isDiscontinuity, segment, variables, type, codecs, bandwidth) {
     const segmentRef = this.createSegmentReference_(
         initSegmentRef,
         /* previousReference= */ null,
@@ -2217,10 +2259,22 @@ shaka.hls.HlsParser = class {
     if (mimeType == 'video/mp4' || mimeType == 'audio/mp4') {
       // We also need the init segment to get the correct timescale. But if the
       // stream is self-initializing, use the same response for both.
-      const fetches = [this.fetchStartOfSegment_(segmentRef)];
+      const fetches = [this.fetchStartOfSegment_(
+          segmentRef,
+          type,
+          mimeType,
+          codecs,
+          bandwidth,
+      )];
 
       if (initSegmentRef) {
-        fetches.push(this.fetchStartOfSegment_(initSegmentRef));
+        fetches.push(this.fetchStartOfSegment_(
+            initSegmentRef,
+            type,
+            mimeType,
+            codecs,
+            bandwidth,
+        ));
       }
 
       const responses = await Promise.all(fetches);
@@ -2236,7 +2290,13 @@ shaka.hls.HlsParser = class {
     }
 
     if (mimeType == 'video/mp2t') {
-      const response = await this.fetchStartOfSegment_(segmentRef);
+      const response = await this.fetchStartOfSegment_(
+          segmentRef,
+          type,
+          mimeType,
+          codecs,
+          bandwidth,
+      );
       goog.asserts.assert(response.data, 'Should have a response body!');
       return this.getStartTimeFromTsSegment_(
           verbatimMediaPlaylistUri, response.uri, response.data);
@@ -2614,6 +2674,9 @@ shaka.hls.HlsParser = class {
     const request = shaka.net.NetworkingEngine.makeRequest(
         [absoluteUri], this.config_.retryParameters);
 
+    const format = shaka.util.CmcdManager.StreamingFormat.HLS;
+    this.playerInterface_.modifyManifestRequest(request, {format: format});
+
     return this.makeNetworkRequest_(request, requestType);
   }
 

package/lib/media/quality_observer.js

@@ -0,0 +1,291 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.media.QualityObserver');
+
+goog.require('shaka.media.IPlayheadObserver');
+goog.require('shaka.log');
+
+/**
+ * Monitors the quality of content being appended to the source
+ * buffers and fires onQualityChange events when the media quality
+ * at the playhead changes.
+ *
+ * @implements {shaka.media.IPlayheadObserver}
+ * @final
+ */
+shaka.media.QualityObserver = class {
+  /**
+   * Creates a new QualityObserver.
+   *
+   * @param {!function():!shaka.extern.BufferedInfo} getBufferedInfo
+   *  Buffered info is needed to purge QualityChanges that are no
+   * longer relevant.
+   */
+  constructor(getBufferedInfo) {
+    /**
+     * @private {!Map.<string,!shaka.media.QualityObserver.ContentTypeState>}
+     */
+    this.contentTypeStates_ = new Map();
+
+    /** @private {shaka.media.QualityObserver.EventListener} */
+    this.onQualityChange_ = (mediaQuality, position) => {};
+
+    /** @private function():!shaka.extern.BufferedInfo */
+    this.getBufferedInfo_ = getBufferedInfo;
+  }
+
+  /**
+   * Set all the listeners. This overrides any previous calls to |setListeners|.
+   *
+   * @param {shaka.media.QualityObserver.EventListener} onQualityChange
+   */
+  setListeners(onQualityChange) {
+    this.onQualityChange_ = onQualityChange;
+  }
+
+  /** @override */
+  release() {
+    this.contentTypeStates_.clear();
+  }
+
+  /**
+   * Get the ContenTypeState for a contentType, creating a new
+   * one if necessary.
+   *
+   * @param {!string} contentType
+   *  The contend type e.g. "video" or "audio".
+   * @return {!shaka.media.QualityObserver.ContentTypeState}
+   * @private
+   */
+  getContentTypeState_(contentType) {
+    let contentTypeState = this.contentTypeStates_.get(contentType);
+    if (!contentTypeState) {
+      contentTypeState = {
+        qualityChangePositions: [],
+        currentQuality: null,
+        contentType: contentType,
+      };
+      this.contentTypeStates_.set(contentType, contentTypeState);
+    }
+    return contentTypeState;
+  }
+
+  /**
+   * Adds a QualityChangePosition for the contentType identified by
+   * the mediaQuality.contentType.
+   *
+   * @param {!shaka.extern.MediaQualityInfo} mediaQuality
+   * @param {!number} position
+   *  Position in seconds of the quality change.
+   */
+  addMediaQualityChange(mediaQuality, position) {
+    const contentTypeState =
+      this.getContentTypeState_(mediaQuality.contentType);
+
+    // Remove unneeded QualityChangePosition(s) before adding the new one
+    this.purgeQualityChangePositions_(contentTypeState);
+
+    const newChangePosition = {
+      mediaQuality: mediaQuality,
+      position: position,
+    };
+
+    const changePositions = contentTypeState.qualityChangePositions;
+    const insertBeforeIndex = changePositions.findIndex(
+        (qualityChange) => (qualityChange.position >= position));
+
+    if (insertBeforeIndex >= 0) {
+      const duplicatePositions =
+        (changePositions[insertBeforeIndex].position == position) ? 1 : 0;
+      changePositions.splice(
+          insertBeforeIndex, duplicatePositions, newChangePosition);
+    } else {
+      changePositions.push(newChangePosition);
+    }
+  }
+
+  /**
+   * Determines the media quality at a specific position in the source buffer.
+   *
+   * @param {!number} position
+   *  Position in seconds
+   * @param {!shaka.media.QualityObserver.ContentTypeState} contentTypeState
+   * @return {?shaka.extern.MediaQualityInfo}
+   * @private
+   */
+  static getMediaQualityAtPosition_(position, contentTypeState) {
+    // The qualityChangePositions must be ordered by position ascending
+    // Find the last QualityChangePosition prior to the position
+    const changePositions = contentTypeState.qualityChangePositions;
+    for (let i = changePositions.length - 1; i >= 0; i--) {
+      const qualityChange = changePositions[i];
+      if (qualityChange.position <= position) {
+        return qualityChange.mediaQuality;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Determines if two MediaQualityInfo objects are the same or not.
+   *
+   * @param {?shaka.extern.MediaQualityInfo} mq1
+   * @param {?shaka.extern.MediaQualityInfo} mq2
+   * @return {boolean}
+   * @private
+   */
+  static mediaQualitiesAreTheSame_(mq1, mq2) {
+    if (mq1 === mq2) {
+      return true;
+    }
+    if (!mq1 || !mq2) {
+      return false;
+    }
+    return (mq1.bandwidth == mq2.bandwidth) &&
+      (mq1.audioSamplingRate == mq2.audioSamplingRate) &&
+      (mq1.codecs == mq2.codecs) &&
+      (mq1.contentType == mq2.contentType) &&
+      (mq1.frameRate == mq2.frameRate) &&
+      (mq1.height == mq2.height) &&
+      (mq1.mimeType == mq2.mimeType) &&
+      (mq1.channelsCount == mq2.channelsCount) &&
+      (mq1.pixelAspectRatio == mq2.pixelAspectRatio) &&
+      (mq1.width == mq2.width);
+  }
+
+  /** @override */
+  poll(positionInSeconds, wasSeeking) {
+    for (const contentTypeState of this.contentTypeStates_.values()) {
+      const qualityAtPosition =
+        shaka.media.QualityObserver.getMediaQualityAtPosition_(
+            positionInSeconds, contentTypeState);
+      if (qualityAtPosition &&
+          !shaka.media.QualityObserver.mediaQualitiesAreTheSame_(
+              contentTypeState.currentQuality, qualityAtPosition)) {
+        if (this.positionIsBuffered_(
+            positionInSeconds, qualityAtPosition.contentType)) {
+          contentTypeState.currentQuality = qualityAtPosition;
+          shaka.log.debug('Media quality changed at position ' +
+            positionInSeconds + ' ' + JSON.stringify(qualityAtPosition));
+          this.onQualityChange_(
+              qualityAtPosition, positionInSeconds);
+        }
+      }
+    }
+  }
+
+  /**
+   * Determine if a position is buffered for a given content type.
+   *
+   * @param {!number} position
+   * @param {!string} contentType
+   * @private
+   */
+  positionIsBuffered_(position, contentType) {
+    const bufferedInfo = this.getBufferedInfo_();
+    const bufferedRanges = bufferedInfo[contentType];
+    if (bufferedRanges && bufferedRanges.length > 0) {
+      const bufferStart = bufferedRanges[0].start;
+      const bufferEnd = bufferedRanges[bufferedRanges.length - 1].end;
+      if (position >= bufferStart && position < bufferEnd) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Removes the QualityChangePosition(s) that are not relevant to the buffered
+   * content of the specified contentType. Note that this function is
+   * invoked just before adding the quality change info associated with
+   * the next media segment to be appended.
+   *
+   * @param {!shaka.media.QualityObserver.ContentTypeState} contentTypeState
+   * @private
+   */
+  purgeQualityChangePositions_(contentTypeState) {
+    const bufferedInfo = this.getBufferedInfo_();
+    const bufferedRanges = bufferedInfo[contentTypeState.contentType];
+
+    if (bufferedRanges && bufferedRanges.length > 0) {
+      const bufferStart = bufferedRanges[0].start;
+      const bufferEnd = bufferedRanges[bufferedRanges.length - 1].end;
+      const oldChangePositions = contentTypeState.qualityChangePositions;
+      contentTypeState.qualityChangePositions =
+        oldChangePositions.filter(
+            (qualityChange, index) => {
+              // Remove all but last quality change before bufferStart.
+              if ((qualityChange.position <= bufferStart) &&
+                (index + 1 < oldChangePositions.length) &&
+                (oldChangePositions[index + 1].position <= bufferStart)) {
+                return false;
+              }
+              // Remove all quality changes after bufferEnd.
+              if (qualityChange.position >= bufferEnd) {
+                return false;
+              }
+              return true;
+            });
+    } else {
+      // Nothing is buffered; so remove all quality changes.
+      contentTypeState.qualityChangePositions = [];
+    }
+  }
+};
+
+/**
+ * @typedef {function(shaka.extern.MediaQualityInfo, number)}
+ *
+ * @description
+ * A callback function used to notify the player when media quality changes
+ * are detected at the playhead.
+ *
+ * The first argument is information about media quality at the playhead
+ * position.
+ *
+ * The second argument is the playhead position in seconds.
+ */
+shaka.media.QualityObserver.EventListener;
+
+/**
+  * @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'
+  */
+shaka.media.QualityObserver.ContentTypeState;

package/lib/media/segment_index.js

@@ -427,6 +427,12 @@ shaka.media.SegmentIndex = class {
     return new shaka.media.SegmentIterator(this, index, partialSegmentIndex);
   }
 
+  /**
+   * @return {boolean}
+   */
+  isEmpty() {
+    return this.references.length == 0;
+  }
 
   /**
    * Create a SegmentIndex for a single segment of the given start time and