shaka-player 4.9.13 → 4.10.1

package/lib/hls/manifest_text_parser.js

@@ -295,6 +295,7 @@ shaka.hls.ManifestTextParser.MEDIA_PLAYLIST_TAGS = [
   'EXT-X-SERVER-CONTROL',
   'EXT-X-SKIP',
   'EXT-X-PART-INF',
+  'EXT-X-DATERANGE',
 ];
 
 

package/lib/media/adaptation_set_criteria.js

@@ -115,11 +115,12 @@ shaka.media.PreferenceBasedCriteria = class {
    * @param {string=} videoLabel
    * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
    * @param {boolean=} enableAudioGroups
+   * @param {string=} audioCodec
    */
   constructor(language, role, channelCount, hdrLevel, spatialAudio,
       videoLayout, audioLabel = '', videoLabel = '',
       codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD,
-      enableAudioGroups = false) {
+      enableAudioGroups = false, audioCodec = '') {
     /** @private {string} */
     this.language_ = language;
     /** @private {string} */
@@ -140,6 +141,8 @@ shaka.media.PreferenceBasedCriteria = class {
     this.codecSwitchingStrategy_ = codecSwitchingStrategy;
     /** @private {boolean} */
     this.enableAudioGroups_ = enableAudioGroups;
+    /** @private {string} */
+    this.audioCodec_ = audioCodec;
   }
 
   /** @override */
@@ -229,6 +232,16 @@ shaka.media.PreferenceBasedCriteria = class {
       shaka.log.warning('No exact match for spatial audio could be found.');
     }
 
+    if (this.audioCodec_) {
+      const byAudioCodec = Class.filterVariantsByAudioCodec_(
+          current, this.audioCodec_);
+      if (byAudioCodec.length) {
+        current = byAudioCodec;
+      } else {
+        shaka.log.warning('No exact match for audio codec could be found.');
+      }
+    }
+
     const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
       shaka.config.CodecSwitchingStrategy.SMOOTH &&
         shaka.media.Capabilities.isChangeTypeSupported();
@@ -403,4 +416,21 @@ shaka.media.PreferenceBasedCriteria = class {
       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/drm_engine.js

@@ -2225,9 +2225,12 @@ shaka.media.DrmEngine = class {
     /** @type {!Set.<string>} */
     const keyIds = new Set();
 
+    /** @type {!Set.<string>} */
+    const keySystemUris = new Set();
+
     shaka.media.DrmEngine.processDrmInfos_(
         drmInfos, encryptionSchemes, licenseServers, serverCerts,
-        serverCertificateUris, initDatas, keyIds);
+        serverCertificateUris, initDatas, keyIds, keySystemUris);
 
     if (encryptionSchemes.length > 1) {
       shaka.log.warning('Multiple unique encryption schemes found! ' +
@@ -2268,6 +2271,10 @@ shaka.media.DrmEngine = class {
       keyIds,
     };
 
+    if (keySystemUris.size > 0) {
+      res.keySystemUris = keySystemUris;
+    }
+
     for (const info of drmInfos) {
       if (info.distinctiveIdentifierRequired) {
         res.distinctiveIdentifierRequired = info.distinctiveIdentifierRequired;
@@ -2369,11 +2376,12 @@ shaka.media.DrmEngine = class {
    * @param {!Array.<string>} serverCertificateUris
    * @param {!Array.<!shaka.extern.InitDataOverride>} initDatas
    * @param {!Set.<string>} keyIds
+   * @param {!Set.<string>} [keySystemUris]
    * @private
    */
   static processDrmInfos_(
       drmInfos, encryptionSchemes, licenseServers, serverCerts,
-      serverCertificateUris, initDatas, keyIds) {
+      serverCertificateUris, initDatas, keyIds, keySystemUris) {
     /** @type {function(shaka.extern.InitDataOverride,
      *                  shaka.extern.InitDataOverride):boolean} */
     const initDataOverrideEqual = (a, b) => {
@@ -2437,6 +2445,12 @@ shaka.media.DrmEngine = class {
           keyIds.add(keyId);
         }
       }
+
+      if (drmInfo.keySystemUris && keySystemUris) {
+        for (const keySystemUri of drmInfo.keySystemUris) {
+          keySystemUris.add(keySystemUri);
+        }
+      }
     }
 
     if (clearKeyLicenseServers.length == 1) {

package/lib/media/manifest_filterer.js

@@ -51,11 +51,13 @@ shaka.media.ManifestFilterer = class {
     goog.asserts.assert(manifest, 'Manifest should exist!');
     await shaka.util.StreamUtils.filterManifest(this.drmEngine_, manifest,
         this.config_.drm.preferredKeySystems);
-    shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
-        manifest,
-        this.config_.preferredVideoCodecs,
-        this.config_.preferredAudioCodecs,
-        this.config_.preferredDecodingAttributes);
+    if (!this.config_.streaming.dontChooseCodecs) {
+      shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
+          manifest,
+          this.config_.preferredVideoCodecs,
+          this.config_.preferredAudioCodecs,
+          this.config_.preferredDecodingAttributes);
+    }
     this.checkPlayableVariants_(manifest);
     return this.filterManifestWithRestrictions(manifest);
   }

package/lib/media/preload_manager.js

@@ -38,11 +38,10 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
   /**
    * @param {string} assetUri
    * @param {?string} mimeType
-   * @param {number} startTimeOfLoad
    * @param {?number} startTime
    * @param {*} playerInterface
    */
-  constructor(assetUri, mimeType, startTimeOfLoad, startTime, playerInterface) {
+  constructor(assetUri, mimeType, startTime, playerInterface) {
     super();
 
     // Making the playerInterface a * and casting it to the right type allows
@@ -67,9 +66,6 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
     /** @private {?shaka.media.AdaptationSetCriteria} */
     this.currentAdaptationSetCriteria_ = null;
 
-    /** @private {number} */
-    this.startTimeOfLoad_ = startTimeOfLoad;
-
     /** @private {number} */
     this.startTimeOfDrm_ = 0;
 
@@ -196,16 +192,18 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
     this.queuedOperations_ = null;
   }
 
+  /** @param {number} offset */
+  setOffsetToStartTime(offset) {
+    if (this.startTime_ && offset) {
+      this.startTime_ += offset;
+    }
+  }
+
   /** @return {?number} */
   getStartTime() {
     return this.startTime_;
   }
 
-  /** @return {number} */
-  getStartTimeOfLoad() {
-    return this.startTimeOfLoad_;
-  }
-
   /** @return {number} */
   getStartTimeOfDRM() {
     return this.startTimeOfDrm_;

package/lib/media/presentation_timeline.js

@@ -247,12 +247,22 @@ shaka.media.PresentationTimeline = class {
       return;
     }
 
-    const firstStartTime = timeline[0].start + startOffset;
-    const lastEndTime = timeline[timeline.length - 1].end + startOffset;
+    // Date.now() is in milliseconds, from which we compute "now" in seconds.
+    const now = (Date.now() + this.clockOffset_) / 1000.0;
+    // Exclude time ranges that are in the "future".
+    const timelineForStart = timeline.filter((timeRange) =>
+      timeRange.start + startOffset < now);
+    if (timelineForStart.length == 0) {
+      return;
+    }
+
+    const firstStartTime = timelineForStart[0].start + startOffset;
+    const lastEndTime = timelineForStart[timelineForStart.length - 1].end +
+      startOffset;
 
     this.notifyMinSegmentStartTime(firstStartTime);
 
-    this.maxSegmentDuration_ = timeline.reduce(
+    this.maxSegmentDuration_ = timelineForStart.reduce(
         (max, r) => { return Math.max(max, r.end - r.start); },
         this.maxSegmentDuration_);
 
@@ -263,8 +273,6 @@ shaka.media.PresentationTimeline = class {
             !this.startTimeLocked_) {
       // Since we have explicit segment end times, calculate a presentation
       // start based on them.  This start time accounts for drift.
-      // Date.now() is in milliseconds, from which we compute "now" in seconds.
-      const now = (Date.now() + this.clockOffset_) / 1000.0;
       this.presentationStartTime_ =
             now - this.maxSegmentEndTime_ - this.maxSegmentDuration_;
     }
@@ -323,6 +331,17 @@ shaka.media.PresentationTimeline = class {
   }
 
 
+  /**
+   * Gets the end time of the last available segment.
+   *
+   * @return {?number}
+   * @export
+   */
+  getMaxSegmentEndTime() {
+    return this.maxSegmentEndTime_;
+  }
+
+
   /**
    * Lock the presentation timeline's start time.  After this is called, no
    * further adjustments to presentationStartTime_ will be permitted.
@@ -630,6 +649,19 @@ shaka.media.PresentationTimeline = class {
     this.availabilityTimeOffset_ = offset;
   }
 
+
+  /**
+   * Gets the presentation's segment availability time offset. This should be
+   * only configured for Low Latency Dash.
+   *
+   * @return {number} availabilityTimeOffset parameter
+   * @export
+   */
+  getAvailabilityTimeOffset() {
+    return this.availabilityTimeOffset_;
+  }
+
+
   /**
    * Debug only: assert that the timeline parameters make sense for the type
    * of presentation (VOD, IPR, live).

package/lib/media/quality_observer.js

@@ -8,8 +8,10 @@ goog.provide('shaka.media.QualityObserver');
 
 goog.require('shaka.media.IPlayheadObserver');
 goog.require('shaka.log');
+goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.FakeEventTarget');
+goog.require('shaka.util.ManifestParserUtils');
 
 /**
  * Monitors the quality of content being appended to the source buffers and
@@ -152,12 +154,39 @@ shaka.media.QualityObserver = class extends shaka.util.FakeEventTarget {
   /** @override */
   poll(positionInSeconds, wasSeeking) {
     for (const contentTypeState of this.contentTypeStates_.values()) {
+      const currentQuality = contentTypeState.currentQuality;
       const qualityAtPosition =
         shaka.media.QualityObserver.getMediaQualityAtPosition_(
             positionInSeconds, contentTypeState);
-      if (qualityAtPosition &&
+
+      const differentQualities = qualityAtPosition &&
           !shaka.media.QualityObserver.mediaQualitiesAreTheSame_(
-              contentTypeState.currentQuality, qualityAtPosition)) {
+              currentQuality, qualityAtPosition);
+      const differentLabel = qualityAtPosition && currentQuality &&
+          qualityAtPosition.label && currentQuality.label &&
+          currentQuality.label !== qualityAtPosition.label;
+      const differentLanguage = qualityAtPosition && currentQuality &&
+          qualityAtPosition.language && currentQuality.language &&
+          currentQuality.language !== qualityAtPosition.language;
+      const differentRoles = qualityAtPosition && currentQuality &&
+          qualityAtPosition.roles && currentQuality.roles &&
+          !shaka.util.ArrayUtils.equal(currentQuality.roles,
+              qualityAtPosition.roles);
+
+      if (differentLabel || differentLanguage || differentRoles) {
+        if (this.positionIsBuffered_(
+            positionInSeconds, qualityAtPosition.contentType)) {
+          contentTypeState.currentQuality = qualityAtPosition;
+
+          const event = new shaka.util.FakeEvent('audiotrackchange', new Map([
+            ['quality', qualityAtPosition],
+            ['position', positionInSeconds],
+          ]));
+          this.dispatchEvent(event);
+        }
+      }
+
+      if (differentQualities) {
         if (this.positionIsBuffered_(
             positionInSeconds, qualityAtPosition.contentType)) {
           contentTypeState.currentQuality = qualityAtPosition;
@@ -232,6 +261,43 @@ shaka.media.QualityObserver = class extends shaka.util.FakeEventTarget {
       contentTypeState.qualityChangePositions = [];
     }
   }
+
+  /**
+   * Create a MediaQualityInfo object from a stream object.
+   *
+   * @param {!shaka.extern.Stream} stream
+   * @return {!shaka.extern.MediaQualityInfo}
+   */
+  static createQualityInfo(stream) {
+    const basicQuality = {
+      bandwidth: stream.bandwidth || 0,
+      audioSamplingRate: null,
+      codecs: stream.codecs,
+      contentType: stream.type,
+      frameRate: null,
+      height: null,
+      mimeType: stream.mimeType,
+      channelsCount: null,
+      pixelAspectRatio: null,
+      width: null,
+      label: null,
+      roles: stream.roles,
+      language: null,
+    };
+    if (stream.type == shaka.util.ManifestParserUtils.ContentType.VIDEO) {
+      basicQuality.frameRate = stream.frameRate || null;
+      basicQuality.height = stream.height || null;
+      basicQuality.pixelAspectRatio = stream.pixelAspectRatio || null;
+      basicQuality.width = stream.width || null;
+    }
+    if (stream.type == shaka.util.ManifestParserUtils.ContentType.AUDIO) {
+      basicQuality.audioSamplingRate = stream.audioSamplingRate;
+      basicQuality.channelsCount = stream.channelsCount;
+      basicQuality.label = stream.label || null;
+      basicQuality.language = stream.language;
+    }
+    return basicQuality;
+  }
 };
 
 /**

package/lib/media/segment_reference.js

@@ -46,7 +46,7 @@ shaka.media.InitSegmentReference = class {
     /** @const {?number} */
     this.endByte = endByte;
 
-    /** @const {shaka.extern.MediaQualityInfo|null} */
+    /** @type {shaka.extern.MediaQualityInfo|null} */
     this.mediaQuality = mediaQuality;
 
     /** @type {number|null} */

package/lib/media/segment_utils.js

@@ -327,12 +327,39 @@ shaka.media.SegmentUtils = class {
             case 'avc3':
               codecBase = 'dvav';
               break;
+            case 'av01':
+              codecBase = 'dav1';
+              break;
           }
           const parsedDVCCBox = shaka.util.Mp4BoxParsers.parseDVCC(
               codecBase, box.reader, box.name);
           videoCodecs.push(parsedDVCCBox.codec);
           hasVideo = true;
         })
+        .box('dvvC', (box) => {
+          let codecBase = baseBox || '';
+          switch (baseBox) {
+            case 'hvc1':
+              codecBase = 'dvh1';
+              break;
+            case 'hev1':
+              codecBase = 'dvhe';
+              break;
+            case 'avc1':
+              codecBase = 'dva1';
+              break;
+            case 'avc3':
+              codecBase = 'dvav';
+              break;
+            case 'av01':
+              codecBase = 'dav1';
+              break;
+          }
+          const parsedDVCCBox = shaka.util.Mp4BoxParsers.parseDVVC(
+              codecBase, box.reader, box.name);
+          videoCodecs.push(parsedDVCCBox.codec);
+          hasVideo = true;
+        })
         .fullBox('vpcC', (box) => {
           const codecBase = baseBox || '';
           const parsedVPCCBox = shaka.util.Mp4BoxParsers.parseVPCC(
@@ -341,7 +368,12 @@ shaka.media.SegmentUtils = class {
           hasVideo = true;
         })
         .box('av1C', (box) => {
-          const codecBase = baseBox || '';
+          let codecBase = baseBox || '';
+          switch (baseBox) {
+            case 'dav1':
+              codecBase = 'av01';
+              break;
+          }
           const parsedAV1CBox = shaka.util.Mp4BoxParsers.parseAV1C(
               codecBase, box.reader, box.name);
           videoCodecs.push(parsedAV1CBox.codec);

package/lib/media/streaming_engine.js

@@ -1182,7 +1182,12 @@ shaka.media.StreamingEngine = class {
     if (!mediaState.stream.segmentIndex) {
       const thisStream = mediaState.stream;
 
-      await mediaState.stream.createSegmentIndex();
+      try {
+        await mediaState.stream.createSegmentIndex();
+      } catch (error) {
+        await this.handleStreamingError_(mediaState, error);
+        return;
+      }
 
       if (thisStream != mediaState.stream) {
         // We switched streams while in the middle of this async call to
@@ -1562,9 +1567,11 @@ shaka.media.StreamingEngine = class {
       const isMP4 = stream.mimeType == 'video/mp4' ||
               stream.mimeType == 'audio/mp4';
       const isReadableStreamSupported = window.ReadableStream;
+      const lowLatencyMode = this.config_.lowLatencyMode &&
+          this.manifest_.isLowLatency;
       // Enable MP4 low latency streaming with ReadableStream chunked data.
       // And only for DASH and HLS with byterange optimization.
-      if (this.config_.lowLatencyMode && isReadableStreamSupported && isMP4 &&
+      if (lowLatencyMode && isReadableStreamSupported && isMP4 &&
           (this.manifest_.type != shaka.media.ManifestParser.HLS ||
           reference.hasByterangeOptimization())) {
         let remaining = new Uint8Array(0);
@@ -1655,7 +1662,7 @@ shaka.media.StreamingEngine = class {
               reference.startTime, /* skipFirst= */ true);
         }
       } else {
-        if (this.config_.lowLatencyMode && !isReadableStreamSupported) {
+        if (lowLatencyMode && !isReadableStreamSupported) {
           shaka.log.warning('Low latency streaming mode is enabled, but ' +
             'ReadableStream is not supported by the browser.');
         }
@@ -1986,46 +1993,11 @@ shaka.media.StreamingEngine = class {
         }
       }
 
-      const setProperties = async () => {
-        /**
-         * @type {!Map.<shaka.util.ManifestParserUtils.ContentType,
-         *              shaka.extern.Stream>}
-         */
-        const streamsByType = new Map();
-        if (this.currentVariant_.audio) {
-          streamsByType.set(ContentType.AUDIO, this.currentVariant_.audio);
-        }
-        if (this.currentVariant_.video) {
-          streamsByType.set(ContentType.VIDEO, this.currentVariant_.video);
-        }
-        try {
-          mediaState.lastAppendWindowStart = appendWindowStart;
-          mediaState.lastAppendWindowEnd = appendWindowEnd;
-          mediaState.lastCodecs = codecs;
-          mediaState.lastMimeType = mimeType;
-          mediaState.lastTimestampOffset = timestampOffset;
-
-          const ignoreTimestampOffset = this.manifest_.sequenceMode ||
-              this.manifest_.type == shaka.media.ManifestParser.HLS;
-
-          await this.playerInterface_.mediaSourceEngine.setStreamProperties(
-              mediaState.type, timestampOffset, appendWindowStart,
-              appendWindowEnd, ignoreTimestampOffset,
-              reference.mimeType || mediaState.stream.mimeType,
-              reference.codecs || mediaState.stream.codecs, streamsByType);
-        } catch (error) {
-          mediaState.lastAppendWindowStart = null;
-          mediaState.lastAppendWindowEnd = null;
-          mediaState.lastCodecs = null;
-          mediaState.lastTimestampOffset = null;
-
-          throw error;
-        }
-      };
       // Dispatching init asynchronously causes the sourceBuffers in
       // the MediaSourceEngine to become detached do to race conditions
       // with mediaSource and sourceBuffers being created simultaneously.
-      await setProperties();
+      await this.setProperties_(mediaState, timestampOffset, appendWindowStart,
+          appendWindowEnd, reference, codecs, mimeType);
     }
 
     if (!shaka.media.InitSegmentReference.equal(
@@ -2146,6 +2118,62 @@ shaka.media.StreamingEngine = class {
     await Promise.all(operations);
   }
 
+  /**
+   *
+   * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
+   * @param {number} timestampOffset
+   * @param {number} appendWindowStart
+   * @param {number} appendWindowEnd
+   * @param {!shaka.media.SegmentReference} reference
+   * @param {?string=} codecs
+   * @param {?string=} mimeType
+   * @private
+   */
+  async setProperties_(mediaState, timestampOffset, appendWindowStart,
+      appendWindowEnd, reference, codecs, mimeType) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+
+    /**
+     * @type {!Map.<shaka.util.ManifestParserUtils.ContentType,
+     *              shaka.extern.Stream>}
+     */
+    const streamsByType = new Map();
+    if (this.currentVariant_.audio) {
+      streamsByType.set(ContentType.AUDIO, this.currentVariant_.audio);
+    }
+    if (this.currentVariant_.video) {
+      streamsByType.set(ContentType.VIDEO, this.currentVariant_.video);
+    }
+    try {
+      mediaState.lastAppendWindowStart = appendWindowStart;
+      mediaState.lastAppendWindowEnd = appendWindowEnd;
+      if (codecs) {
+        mediaState.lastCodecs = codecs;
+      }
+      if (mimeType) {
+        mediaState.lastMimeType = mimeType;
+      }
+      mediaState.lastTimestampOffset = timestampOffset;
+
+      const ignoreTimestampOffset = this.manifest_.sequenceMode ||
+          this.manifest_.type == shaka.media.ManifestParser.HLS;
+
+      await this.playerInterface_.mediaSourceEngine.setStreamProperties(
+          mediaState.type, timestampOffset, appendWindowStart,
+          appendWindowEnd, ignoreTimestampOffset,
+          reference.mimeType || mediaState.stream.mimeType,
+          reference.codecs || mediaState.stream.codecs, streamsByType);
+    } catch (error) {
+      mediaState.lastAppendWindowStart = null;
+      mediaState.lastAppendWindowEnd = null;
+      mediaState.lastCodecs = null;
+      mediaState.lastMimeType = null;
+      mediaState.lastTimestampOffset = null;
+
+      throw error;
+    }
+  }
+
 
   /**
    * Appends the given segment and evicts content if required to append.
@@ -2173,7 +2201,18 @@ shaka.media.StreamingEngine = class {
     const shouldParsePrftBox =
       (this.config_.parsePrftBox && !this.parsedPrftEventRaised_);
 
-    if (hasEmsg || shouldParsePrftBox) {
+    const isMP4 = stream.mimeType == 'video/mp4' ||
+            stream.mimeType == 'audio/mp4';
+    let timescale = null;
+    if (reference.initSegmentReference) {
+      timescale = reference.initSegmentReference.timescale;
+    }
+    const shouldFixTimestampOffset = isMP4 && timescale &&
+        stream.type === shaka.util.ManifestParserUtils.ContentType.VIDEO &&
+        this.manifest_.type == shaka.media.ManifestParser.DASH &&
+        this.config_.shouldFixTimestampOffset;
+
+    if (hasEmsg || shouldParsePrftBox || shouldFixTimestampOffset) {
       parser = new shaka.util.Mp4Parser();
     }
 
@@ -2193,8 +2232,46 @@ shaka.media.StreamingEngine = class {
                   reference, box));
     }
 
-    if (hasEmsg || shouldParsePrftBox) {
-      parser.parse(segment);
+    if (shouldFixTimestampOffset) {
+      parser
+          .box('moof', shaka.util.Mp4Parser.children)
+          .box('traf', shaka.util.Mp4Parser.children)
+          .fullBox('tfdt', async (box) => {
+            goog.asserts.assert(
+                box.version != null,
+                'TFDT is a full box and should have a valid version.');
+
+            const parsedTFDT = shaka.util.Mp4BoxParsers.parseTFDTInaccurate(
+                box.reader, box.version);
+
+            const baseMediaDecodeTime = parsedTFDT.baseMediaDecodeTime;
+
+            // In case the time is 0, it is not updated
+            if (!baseMediaDecodeTime) {
+              return;
+            }
+            goog.asserts.assert(typeof(timescale) == 'number',
+                'Should be an number!');
+
+            const scaledMediaDecodeTime = -baseMediaDecodeTime / timescale;
+
+            const comparison1 = Number(mediaState.lastTimestampOffset) || 0;
+
+            if (comparison1 < scaledMediaDecodeTime) {
+              const lastAppendWindowStart = mediaState.lastAppendWindowStart;
+              const lastAppendWindowEnd = mediaState.lastAppendWindowEnd;
+              goog.asserts.assert(typeof(lastAppendWindowStart) == 'number',
+                  'Should be an number!');
+              goog.asserts.assert(typeof(lastAppendWindowEnd) == 'number',
+                  'Should be an number!');
+              await this.setProperties_(mediaState, scaledMediaDecodeTime,
+                  lastAppendWindowStart, lastAppendWindowEnd, reference);
+            }
+          });
+    }
+
+    if (hasEmsg || shouldParsePrftBox || shouldFixTimestampOffset) {
+      parser.parse(segment, /* partialOkay= */ false, isChunkedData);
     }
 
     await this.evict_(mediaState, presentationTime);

package/lib/mss/mss_parser.js

@@ -13,6 +13,7 @@ goog.require('shaka.log');
 goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.ManifestParser');
 goog.require('shaka.media.PresentationTimeline');
+goog.require('shaka.media.QualityObserver');
 goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.mss.ContentProtection');
@@ -233,6 +234,11 @@ shaka.mss.MssParser = class {
     // No-op
   }
 
+  /** @override */
+  setMediaElement(mediaElement) {
+    // No-op
+  }
+
   /**
    * Makes a network request for the manifest and parses the resulting data.
    *
@@ -420,6 +426,9 @@ shaka.mss.MssParser = class {
         type: shaka.media.ManifestParser.MSS,
         serviceDescription: null,
         nextUrl: null,
+        periodCount: 1,
+        gapCount: 0,
+        isLowLatency: false,
       };
 
       // This is the first point where we have a meaningful presentation start
@@ -700,12 +709,14 @@ shaka.mss.MssParser = class {
         initSegmentData = mp4Generator.initSegment();
         this.initSegmentDataByStreamId_.set(stream.id, initSegmentData);
       }
+      const qualityInfo =
+          shaka.media.QualityObserver.createQualityInfo(stream);
       const initSegmentRef = new shaka.media.InitSegmentReference(
           () => [],
           /* startByte= */ 0,
           /* endByte= */ null,
-          /* mediaQuality= */ null,
-          /* timescale= */ undefined,
+          qualityInfo,
+          stream.mssPrivateData.timescale,
           initSegmentData);
 
       const segments = this.createSegments_(initSegmentRef,