shaka-player 3.2.1 → 3.3.1

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

@@ -347,7 +347,8 @@ shaka.media.SegmentIndex = class {
             lastReference.appendWindowStart,
             lastReference.appendWindowEnd,
             lastReference.partialReferences,
-            lastReference.tilesLayout);
+            lastReference.tilesLayout,
+            lastReference.tileDuration);
   }
 
 
@@ -427,6 +428,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

package/lib/media/segment_reference.js

@@ -23,11 +23,13 @@ shaka.media.InitSegmentReference = class {
    *   of the resource containing the segment.
    * @param {number} startByte The offset from the start of the resource to the
    *   start of the segment.
-   * @param {?number} endByte The offset from the start of the resource to the
-   *   end of the segment, inclusive.  A value of null indicates that the
+   * @param {?number} endByte The offset from the start of the resource
+   *   to the end of the segment, inclusive.  A value of null indicates that the
    *   segment extends to the end of the resource.
+   * @param {null|shaka.extern.MediaQualityInfo=} mediaQuality Information about
+   *   the quality of the media associated with this init segment.
    */
-  constructor(uris, startByte, endByte) {
+  constructor(uris, startByte, endByte, mediaQuality = null) {
     /** @type {function():!Array.<string>} */
     this.getUris = uris;
 
@@ -36,6 +38,9 @@ shaka.media.InitSegmentReference = class {
 
     /** @const {?number} */
     this.endByte = endByte;
+
+    /** @const {shaka.extern.MediaQualityInfo|null} */
+    this.mediaQuality = mediaQuality;
   }
 
   /**
@@ -73,6 +78,16 @@ shaka.media.InitSegmentReference = class {
     }
   }
 
+  /**
+   * Returns media quality information for the segments associated with
+   * this init segment.
+   *
+   * @return {?shaka.extern.MediaQualityInfo}
+   */
+  getMediaQuality() {
+    return this.mediaQuality;
+  }
+
   /**
    * Check if two initSegmentReference have all the same values.
    * @param {?shaka.media.InitSegmentReference} reference1
@@ -140,11 +155,15 @@ shaka.media.SegmentReference = class {
    *   The value is a grid-item-dimension consisting of two positive decimal
    *   integers in the format: column-x-row ('4x3'). It describes the
    *   arrangement of Images in a Grid. The minimum valid LAYOUT is '1x1'.
+   * @param {?number=} tileDuration
+   *  The explicit duration of an individual tile within the tiles grid.
+   *  If not provided, the duration should be automatically calculated based on
+   *  the duration of the reference.
    */
   constructor(
       startTime, endTime, uris, startByte, endByte, initSegmentReference,
       timestampOffset, appendWindowStart, appendWindowEnd,
-      partialReferences = [], tilesLayout = '') {
+      partialReferences = [], tilesLayout = '', tileDuration = null) {
     // A preload hinted Partial Segment has the same startTime and endTime.
     goog.asserts.assert(startTime <= endTime,
         'startTime must be less than or equal to endTime');
@@ -191,6 +210,9 @@ shaka.media.SegmentReference = class {
 
     /** @type {?string} */
     this.tilesLayout = tilesLayout;
+
+    /** @type {?number} */
+    this.tileDuration = tileDuration;
   }
 
   /**
@@ -275,6 +297,17 @@ shaka.media.SegmentReference = class {
   getTilesLayout() {
     return this.tilesLayout;
   }
+
+  /**
+   * Returns the segment's explicit tile duration.
+   * Only defined in image segments.
+   *
+   * @return {?number}
+   * @export
+   */
+  getTileDuration() {
+    return this.tileDuration;
+  }
 };
 
 

package/lib/media/streaming_engine.js

@@ -431,6 +431,11 @@ shaka.media.StreamingEngine = class {
       this.playerInterface_.mediaSourceEngine.reinitText(fullMimeType);
     }
 
+    // Releases the segmentIndex of the old stream.
+    if (mediaState.stream.closeSegmentIndex) {
+      mediaState.stream.closeSegmentIndex();
+    }
+
     mediaState.stream = stream;
     mediaState.segmentIterator = null;
 
@@ -623,7 +628,7 @@ shaka.media.StreamingEngine = class {
 
         // Don't clear the buffer unless something is buffered.  This extra
         // check prevents extra, useless calls to clear the buffer.
-        if (somethingBuffered) {
+        if (somethingBuffered || mediaState.performingUpdate) {
           this.forceClearBuffer_(mediaState);
           streamCleared = true;
         }
@@ -863,7 +868,7 @@ shaka.media.StreamingEngine = class {
       return;
     }
 
-    // Make sure the segment index exists.
+    // Make sure the segment index exists. If not, create the segment index.
     if (!mediaState.stream.segmentIndex) {
       const thisStream = mediaState.stream;
 
@@ -873,6 +878,12 @@ shaka.media.StreamingEngine = class {
         // We switched streams while in the middle of this async call to
         // createSegmentIndex.  Abandon this update and schedule a new one if
         // there's not already one pending.
+        // Releases the segmentIndex of the old stream.
+        if (thisStream.closeSegmentIndex) {
+          goog.asserts.assert(!mediaState.stream.segmentIndex,
+              'mediastate.stream should not have segmentIndex yet.');
+          thisStream.closeSegmentIndex();
+        }
         if (mediaState.updateTimer == null) {
           this.scheduleUpdate_(mediaState, 0);
         }
@@ -977,7 +988,10 @@ shaka.media.StreamingEngine = class {
         unscaledBufferingGoal * this.bufferingGoalScale_;
 
     // Check if we've buffered to the end of the presentation.
-    if (timeNeeded >= this.manifest_.presentationTimeline.getDuration()) {
+    const timeUntilEnd =
+        this.manifest_.presentationTimeline.getDuration() - timeNeeded;
+    const oneMicrosecond = 1e-6;
+    if (timeUntilEnd < oneMicrosecond) {
       // We shouldn't rebuffer if the playhead is close to the end of the
       // presentation.
       shaka.log.debug(logPrefix, 'buffered to end of presentation');
@@ -1530,6 +1544,8 @@ shaka.media.StreamingEngine = class {
             throw error;
           }
         };
+        this.playerInterface_.onInitSegmentAppended(
+            reference.startTime, reference.initSegmentReference);
         operations.push(append());
       }
     }
@@ -1555,7 +1571,9 @@ shaka.media.StreamingEngine = class {
 
     const hasClosedCaptions = stream.closedCaptions &&
         stream.closedCaptions.size > 0;
-    if (stream.emsgSchemeIdUris != null && stream.emsgSchemeIdUris.length > 0) {
+    if ((stream.emsgSchemeIdUris != null &&
+        stream.emsgSchemeIdUris.length > 0) ||
+        this.config_.dispatchAllEmsgBoxes) {
       new shaka.util.Mp4Parser()
           .fullBox(
               'emsg',
@@ -1641,7 +1659,8 @@ shaka.media.StreamingEngine = class {
     // See DASH sec. 5.10.3.3.1
     // If a DASH client detects an event message box with a scheme that is not
     // defined in MPD, the client is expected to ignore it.
-    if (emsgSchemeIdUris.includes(schemeId)) {
+    if (emsgSchemeIdUris.includes(schemeId) ||
+        this.config_.dispatchAllEmsgBoxes) {
       // See DASH sec. 5.10.4.1
       // A special scheme in DASH used to signal manifest updates.
       if (schemeId == 'urn:mpeg:dash:event:2012') {
@@ -1662,7 +1681,8 @@ shaka.media.StreamingEngine = class {
 
         // Dispatch an event to notify the application about the emsg box.
         const eventName = shaka.Player.EventName.Emsg;
-        const event = new shaka.util.FakeEvent(eventName, {'detail': emsg});
+        const data = (new Map()).set('detail', emsg);
+        const event = new shaka.util.FakeEvent(eventName, data);
         this.playerInterface_.onEvent(event);
       }
     }
@@ -1763,6 +1783,19 @@ shaka.media.StreamingEngine = class {
 
     shaka.log.v2('fetching: reference=', reference);
 
+    const stream = mediaState.stream;
+    this.playerInterface_.modifySegmentRequest(
+        request,
+        {
+          type: stream.type,
+          init: reference instanceof shaka.media.InitSegmentReference,
+          duration: reference.endTime - reference.startTime,
+          mimeType: stream.mimeType,
+          codecs: stream.codecs,
+          bandwidth: stream.bandwidth,
+        },
+    );
+
     const op = this.playerInterface_.netEngine.request(requestType, request);
     mediaState.operation = op;
     const response = await op.promise;
@@ -1926,12 +1959,15 @@ shaka.media.StreamingEngine = class {
  * @typedef {{
  *   getPresentationTime: function():number,
  *   getBandwidthEstimate: function():number,
+ *   modifySegmentRequest: function(shaka.extern.Request,
+ *     shaka.util.CmcdManager.SegmentInfo),
  *   mediaSourceEngine: !shaka.media.MediaSourceEngine,
  *   netEngine: shaka.net.NetworkingEngine,
  *   onError: function(!shaka.util.Error),
  *   onEvent: function(!Event),
  *   onManifestUpdate: function(),
- *   onSegmentAppended: function()
+ *   onSegmentAppended: function(),
+ *   onInitSegmentAppended: function(!number,!shaka.media.InitSegmentReference)
  * }}
  *
  * @property {function():number} getPresentationTime
@@ -1939,6 +1975,9 @@ shaka.media.StreamingEngine = class {
  *   viewer is seeing on screen right now.
  * @property {function():number} getBandwidthEstimate
  *   Get the estimated bandwidth in bits per second.
+ * @property {function(shaka.extern.Request,
+ *   shaka.extern.Cmcd.SegmentInfo)} modifySegmentRequest
+ *   The request modifier
  * @property {!shaka.media.MediaSourceEngine} mediaSourceEngine
  *   The MediaSourceEngine. The caller retains ownership.
  * @property {shaka.net.NetworkingEngine} netEngine
@@ -1953,6 +1992,9 @@ shaka.media.StreamingEngine = class {
  *   Called when an embedded 'emsg' box should trigger a manifest update.
  * @property {function()} onSegmentAppended
  *   Called after a segment is successfully appended to a MediaSource.
+ * @property
+ *  {function(!number, !shaka.media.InitSegmentReference)} onInitSegmentAppended
+ *   Called when an init segment is appended to a MediaSource.
  */
 shaka.media.StreamingEngine.PlayerInterface;
 

package/lib/net/http_fetch_plugin.js

@@ -27,10 +27,12 @@ shaka.net.HttpFetchPlugin = class {
    * @param {shaka.net.NetworkingEngine.RequestType} requestType
    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
    *   progress event happened.
+   * @param {shaka.extern.HeadersReceived} headersReceived Called when the
+   *   headers for the download are received, but before the body is.
    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
    * @export
    */
-  static parse(uri, request, requestType, progressUpdated) {
+  static parse(uri, request, requestType, progressUpdated, headersReceived) {
     const headers = new shaka.net.HttpFetchPlugin.Headers_();
     shaka.util.MapUtils.asMap(request.headers).forEach((value, key) => {
       headers.append(key, value);
@@ -55,7 +57,7 @@ shaka.net.HttpFetchPlugin = class {
     };
 
     const pendingRequest = shaka.net.HttpFetchPlugin.request_(
-        uri, requestType, init, abortStatus, progressUpdated,
+        uri, requestType, init, abortStatus, progressUpdated, headersReceived,
         request.streamDataCallback);
 
     /** @type {!shaka.util.AbortableOperation} */
@@ -92,12 +94,13 @@ shaka.net.HttpFetchPlugin = class {
    * @param {!RequestInit} init
    * @param {shaka.net.HttpFetchPlugin.AbortStatus} abortStatus
    * @param {shaka.extern.ProgressUpdated} progressUpdated
+   * @param {shaka.extern.HeadersReceived} headersReceived
    * @param {?function(BufferSource):!Promise} streamDataCallback
    * @return {!Promise<!shaka.extern.Response>}
    * @private
    */
   static async request_(uri, requestType, init, abortStatus, progressUpdated,
-      streamDataCallback) {
+      headersReceived, streamDataCallback) {
     const fetch = shaka.net.HttpFetchPlugin.fetch_;
     const ReadableStream = shaka.net.HttpFetchPlugin.ReadableStream_;
     let response;
@@ -113,6 +116,10 @@ shaka.net.HttpFetchPlugin = class {
       // headers are available. The download itself isn't done until the promise
       // for retrieving the data (arrayBuffer, blob, etc) has resolved.
       response = await fetch(uri, init);
+      // At this point in the process, we have the headers of the response, but
+      // not the body yet.
+      headersReceived(shaka.net.HttpFetchPlugin.headersToGenericObject_(
+          response.headers));
       // Getting the reader in this way allows us to observe the process of
       // downloading the body, instead of just waiting for an opaque promise to
       // resolve.
@@ -194,19 +201,28 @@ shaka.net.HttpFetchPlugin = class {
       }
     }
 
-    const headers = {};
-    /** @type {Headers} */
-    const responseHeaders = response.headers;
-    responseHeaders.forEach((value, key) => {
-      // Since Edge incorrectly return the header with a leading new line
-      // character ('\n'), we trim the header here.
-      headers[key.trim()] = value;
-    });
+    const headers = shaka.net.HttpFetchPlugin.headersToGenericObject_(
+        response.headers);
 
     return shaka.net.HttpPluginUtils.makeResponse(
         headers, arrayBuffer, response.status, uri, response.url, requestType);
   }
 
+  /**
+   * @param {!Headers} headers
+   * @return {!Object.<string, string>}
+   * @private
+   */
+  static headersToGenericObject_(headers) {
+    const headersObj = {};
+    headers.forEach((value, key) => {
+      // Since Edge incorrectly return the header with a leading new line
+      // character ('\n'), we trim the header here.
+      headersObj[key.trim()] = value;
+    });
+    return headersObj;
+  }
+
   /**
    * Determine if the Fetch API is supported in the browser. Note: this is
    * deliberately exposed as a method to allow the client app to use the same
@@ -290,4 +306,8 @@ if (shaka.net.HttpFetchPlugin.isSupported()) {
       'https', shaka.net.HttpFetchPlugin.parse,
       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
       /* progressSupport= */ true);
+  shaka.net.NetworkingEngine.registerScheme(
+      'blob', shaka.net.HttpFetchPlugin.parse,
+      shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
+      /* progressSupport= */ true);
 }

package/lib/net/http_plugin_utils.js

@@ -34,6 +34,7 @@ shaka.net.HttpPluginUtils = class {
         uri: responseURL || uri,
         originalUri: uri,
         data: data,
+        status: status,
         headers: headers,
         fromCache: !!headers['x-shaka-from-cache'],
       };