shaka-player 4.2.11 → 4.2.12

package/docs/tutorials/drm-config.md

@@ -59,15 +59,18 @@ If this is the only `<ContentProtection>` element in the manifest, Shaka will
 try all key systems it knows. (Based on keySystemsByURI in
 {@linksource shaka.extern.DashManifestConfiguration}.)
 
-Through `player.configure()`, you can change the dash key systems mapping by
+Through `player.configure()`, you can update the dash key systems mapping by
 scheme URI:
+
 ```js
 player.configure({
-  dash: {
-    keySystemsByURI: {
-      'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95': 'com.microsoft.playready.recommendation',
-      'urn:uuid:79f0049a-4098-8642-ab92-e65be0885f95': 'com.microsoft.playready.recommendation',
-    }
+  manifest: {
+    dash: {
+      keySystemsByURI: {
+        'urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95': 'com.microsoft.playready.recommendation',
+        'urn:uuid:79f0049a-4098-8642-ab92-e65be0885f95': 'com.microsoft.playready.recommendation',
+      }
+  }
   }
 });
 ```

package/externs/ima.js

@@ -501,6 +501,14 @@ google.ima.dai.api.StreamRequest.prototype.streamActivityMonitorId;
 google.ima.dai.api.StreamRequest.prototype.format;
 
 
+/**
+ * @type {Object.<
+ *   google.ima.dai.api.OmidVerificationVendor,
+ *   (google.ima.dai.api.OmidAccessMode | undefined)>}
+ */
+google.ima.dai.api.StreamRequest.prototype.omidAccessModeRules;
+
+
 /**
  * @enum {string}
  */
@@ -587,3 +595,29 @@ google.ima.dai.api.StreamEvent.Type = {
   SKIPPED: 'skip',
   VIDEO_CLICKED: 'videoClicked',
 };
+
+
+/**
+ * @enum {number}
+ */
+google.ima.dai.api.OmidVerificationVendor = {
+  OTHER: 1,
+  MOAT: 2,
+  DOUBLEVERIFY: 3,
+  INTEGRAL_AD_SCIENCE: 4,
+  PIXELATE: 5,
+  NIELSEN: 6,
+  COMSCORE: 7,
+  MEETRICS: 8,
+  GOOGLE: 9,
+};
+
+
+/**
+ * @enum {string}
+ */
+google.ima.dai.api.OmidAccessMode = {
+  FULL: 'full',
+  DOMAIN: 'domain',
+  LIMITED: 'limited',
+};

package/lib/abr/simple_abr_manager.js

@@ -54,7 +54,7 @@ shaka.abr.SimpleAbrManager = class {
     // of connectivity changes.
     if (navigator.connection && navigator.connection.addEventListener) {
       this.onNetworkInformationChange_ = () => {
-        if (this.config_.useNetworkInformation && this.enabled_) {
+        if (this.enabled_ && this.config_.useNetworkInformation) {
           this.bandwidthEstimator_ = new shaka.abr.EwmaBandwidthEstimator();
           if (this.config_) {
             this.bandwidthEstimator_.configure(this.config_.advanced);

package/lib/cea/mp4_cea_parser.js

@@ -9,6 +9,7 @@ goog.provide('shaka.cea.Mp4CeaParser');
 goog.require('goog.asserts');
 goog.require('shaka.cea.ICeaParser');
 goog.require('shaka.cea.SeiProcessor');
+goog.require('shaka.log');
 goog.require('shaka.util.DataViewReader');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.Mp4Parser');
@@ -122,12 +123,19 @@ shaka.cea.Mp4CeaParser = class {
     // Fields that are found in MOOF boxes
     let defaultSampleDuration = this.defaultSampleDuration_;
     let defaultSampleSize = this.defaultSampleSize_;
-    let sampleData = [];
+    let moofOffset = 0;
+    /** @type {!Array<shaka.util.ParsedTRUNBox>} */
+    let parsedTRUNs = [];
     let baseMediaDecodeTime = null;
     let timescale = shaka.cea.ICeaParser.DEFAULT_TIMESCALE_VALUE;
 
     new Mp4Parser()
-        .box('moof', Mp4Parser.children)
+        .box('moof', (box) => {
+          moofOffset = box.start;
+          // trun box parsing is reset on each moof.
+          parsedTRUNs = [];
+          Mp4Parser.children(box);
+        })
         .box('traf', Mp4Parser.children)
         .fullBox('trun', (box) => {
           goog.asserts.assert(
@@ -136,10 +144,8 @@ shaka.cea.Mp4CeaParser = class {
 
           const parsedTRUN = shaka.util.Mp4BoxParsers.parseTRUN(
               box.reader, box.version, box.flags);
-
-          sampleData = parsedTRUN.sampleData;
+          parsedTRUNs.push(parsedTRUN);
         })
-
         .fullBox('tfhd', (box) => {
           goog.asserts.assert(
               box.flags != null,
@@ -163,7 +169,6 @@ shaka.cea.Mp4CeaParser = class {
             timescale = this.trackIdToTimescale_.get(trackId);
           }
         })
-
         .fullBox('tfdt', (box) => {
           goog.asserts.assert(
               box.version != null,
@@ -176,15 +181,18 @@ shaka.cea.Mp4CeaParser = class {
         })
         .box('mdat', (box) => {
           if (baseMediaDecodeTime === null) {
-            // This field should have been populated by
-            // the Base Media Decode time in the TFDT box
+            // 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, sampleData,
+              defaultSampleDuration, defaultSampleSize, offset, parsedTRUNs,
               captionPackets);
         })
         .parse(mediaSegment, /* partialOkay= */ false);
@@ -199,12 +207,13 @@ shaka.cea.Mp4CeaParser = class {
    * @param {number} timescale
    * @param {number} defaultSampleDuration
    * @param {number} defaultSampleSize
-   * @param {!Array<shaka.util.ParsedTRUNSample>} sampleData
+   * @param {number} offset
+   * @param {!Array<shaka.util.ParsedTRUNBox>} parsedTRUNs
    * @param {!Array<!shaka.cea.ICeaParser.CaptionPacket>} captionPackets
    * @private
    */
   parseMdat_(reader, time, timescale, defaultSampleDuration,
-      defaultSampleSize, sampleData, captionPackets) {
+      defaultSampleSize, offset, parsedTRUNs, captionPackets) {
     let sampleIndex = 0;
 
     // The fields in each ParsedTRUNSample contained in the sampleData
@@ -213,17 +222,24 @@ shaka.cea.Mp4CeaParser = class {
     // composition time offset, we default to 0.
     let sampleSize = defaultSampleSize;
 
+    // Combine all sample data.  This assumes that the samples described across
+    // multiple trun boxes are still continuous in the mdat box.
+    const sampleDatas = parsedTRUNs.map((t) => t.sampleData);
+    const sampleData = [].concat(...sampleDatas);
+
     if (sampleData.length) {
       sampleSize = sampleData[0].sampleSize || defaultSampleSize;
     }
 
+    reader.skip(offset + parsedTRUNs[0].dataOffset);
+
     while (reader.hasMoreData()) {
       const naluSize = reader.readUint32();
       const naluType = reader.readUint8() & 0x1F;
       if (naluType == shaka.cea.ICeaParser.NALU_TYPE_SEI) {
         let timeOffset = 0;
 
-        if (sampleData.length > sampleIndex) {
+        if (sampleIndex < sampleData.length) {
           timeOffset = sampleData[sampleIndex].sampleCompositionTimeOffset || 0;
         }
 
@@ -246,7 +262,7 @@ shaka.cea.Mp4CeaParser = class {
       }
       sampleSize -= (naluSize + 4);
       if (sampleSize == 0) {
-        if (sampleData.length > sampleIndex) {
+        if (sampleIndex < sampleData.length) {
           time += sampleData[sampleIndex].sampleDuration ||
               defaultSampleDuration;
         } else {
@@ -255,7 +271,7 @@ shaka.cea.Mp4CeaParser = class {
 
         sampleIndex++;
 
-        if (sampleData.length > sampleIndex) {
+        if (sampleIndex < sampleData.length) {
           sampleSize = sampleData[sampleIndex].sampleSize || defaultSampleSize;
         } else {
           sampleSize = defaultSampleSize;

package/lib/dash/dash_parser.js

@@ -886,7 +886,19 @@ shaka.dash.DashParser = class {
 
     // Parallel for HLS VIDEO-RANGE as defined in DASH-IF IOP v4.3 6.2.5.1.
     let videoRange;
-    const videoRangeScheme = 'urn:mpeg:mpegB:cicp:TransferCharacteristics';
+
+    // Ref. https://dashif.org/docs/DASH-IF-IOP-v4.3.pdf
+    // If signaled, a Supplemental or Essential Property descriptor
+    // shall be used, with the schemeIdUri set to
+    // urn:mpeg:mpegB:cicp:<Parameter> as defined in
+    // ISO/IEC 23001-8 [49] and <Parameter> one of the
+    // following: ColourPrimaries, TransferCharacteristics,
+    // or MatrixCoefficients.
+    const scheme = 'urn:mpeg:mpegB:cicp';
+    const transferCharacteristicsScheme = `${scheme}:TransferCharacteristics`;
+    const colourPrimariesScheme = `${scheme}:ColourPrimaries`;
+    const matrixCoefficientsScheme = `${scheme}:MatrixCoefficients`;
+
     const getVideoRangeFromTransferCharacteristicCICP = (cicp) => {
       switch (cicp) {
         case 1:
@@ -912,10 +924,13 @@ shaka.dash.DashParser = class {
       const schemeId = prop.getAttribute('schemeIdUri');
       if (schemeId == 'http://dashif.org/guidelines/trickmode') {
         trickModeFor = prop.getAttribute('value');
-      } else if (schemeId == videoRangeScheme) {
+      } else if (schemeId == transferCharacteristicsScheme) {
         videoRange = getVideoRangeFromTransferCharacteristicCICP(
             parseInt(prop.getAttribute('value'), 10),
         );
+      } else if (schemeId == colourPrimariesScheme ||
+                 schemeId == matrixCoefficientsScheme) {
+        continue;
       } else {
         unrecognizedEssentialProperty = true;
       }
@@ -925,7 +940,7 @@ shaka.dash.DashParser = class {
         XmlUtils.findChildren(elem, 'SupplementalProperty');
     for (const prop of supplementalProperties) {
       const schemeId = prop.getAttribute('schemeIdUri');
-      if (schemeId == videoRangeScheme) {
+      if (schemeId == transferCharacteristicsScheme) {
         videoRange = getVideoRangeFromTransferCharacteristicCICP(
             parseInt(prop.getAttribute('value'), 10),
         );

package/lib/hls/hls_parser.js

@@ -1713,6 +1713,13 @@ shaka.hls.HlsParser = class {
       }
     }
 
+    // If there are no roles, and we have defaulted to the subtitle "kind" for
+    // this track, add the implied subtitle role.
+    if (!roles.length &&
+        kind === shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE) {
+      roles.push(shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE);
+    }
+
     const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
         playlist.tags, 'EXT-X-SERVER-CONTROL');
     const canSkipSegments = serverControlTag ?
@@ -1742,7 +1749,7 @@ shaka.hls.HlsParser = class {
       width: undefined,
       height: undefined,
       bandwidth: undefined,
-      roles: roles,
+      roles,
       forced: forced,
       channelsCount,
       audioSamplingRate: null,
@@ -2150,6 +2157,10 @@ shaka.hls.HlsParser = class {
       // We're interested in the duration part.
       const extinfValues = extinfTag.value.split(',');
       const duration = Number(extinfValues[0]);
+      // Skip segments without duration
+      if (duration == 0) {
+        return null;
+      }
       endTime = startTime + duration;
     } else {
       endTime = partialSegmentRefs[partialSegmentRefs.length - 1].endTime;
@@ -2341,9 +2352,9 @@ shaka.hls.HlsParser = class {
           playlist.absoluteUri,
           type,
           hlsAes128Key);
-      previousReference = reference;
 
       if (reference) {
+        previousReference = reference;
         reference.discontinuitySequence = discontinuitySequence;
 
         if (this.config_.hls.ignoreManifestProgramDateTime &&

package/lib/media/drm_engine.js

@@ -354,18 +354,24 @@ shaka.media.DrmEngine = class {
       shaka.media.DrmEngine.replaceDrmInfo_(variants, servers);
     }
 
-    // Make sure all the drm infos are valid and filled in correctly.
+    /** @type {!Set<shaka.extern.DrmInfo>} */
+    const drmInfos = new Set();
     for (const variant of variants) {
-      const drmInfos = this.getVariantDrmInfos_(variant);
-      for (const info of drmInfos) {
-        shaka.media.DrmEngine.fillInDrmInfoDefaults_(
-            info,
-            shaka.util.MapUtils.asMap(this.config_.servers),
-            shaka.util.MapUtils.asMap(this.config_.advanced || {}),
-            this.config_.keySystemsMapping);
+      const variantDrmInfos = this.getVariantDrmInfos_(variant);
+      for (const info of variantDrmInfos) {
+        drmInfos.add(info);
       }
     }
 
+    for (const info of drmInfos) {
+      shaka.media.DrmEngine.fillInDrmInfoDefaults_(
+          info,
+          shaka.util.MapUtils.asMap(this.config_.servers),
+          shaka.util.MapUtils.asMap(this.config_.advanced || {}),
+          this.config_.keySystemsMapping);
+    }
+
+
     /** @type {!Map.<string, MediaKeySystemConfiguration>} */
     let configsByKeySystem;
 

package/lib/media/gap_jumping_controller.js

@@ -58,6 +58,9 @@ shaka.media.GapJumpingController = class {
     /** @private {number} */
     this.prevReadyState_ = video.readyState;
 
+    /** @private {number} */
+    this.startTime_ = 0;
+
     /** @private {number} */
     this.gapsJumped_ = 0;
 
@@ -123,6 +126,18 @@ shaka.media.GapJumpingController = class {
     this.onPollGapJump_();
   }
 
+  /**
+   * Called when playback has started and the video element is
+   * listening for seeks.
+   *
+   * @param {number} startTime
+   */
+  onStarted(startTime) {
+    if (this.video_.seeking && !this.seekingEventReceived_) {
+      this.seekingEventReceived_ = true;
+      this.startTime_ = startTime;
+    }
+  }
 
   /** Called when a seek has started. */
   onSeeking() {
@@ -164,8 +179,8 @@ shaka.media.GapJumpingController = class {
     // while paused on a livestream.  We make an exception for time 0, since we
     // may be _required_ to seek on startup before play can begin, but only if
     // autoplay is enabled.
-    if (this.video_.paused && (this.video_.currentTime != 0 ||
-      (!this.video_.autoplay && this.video_.currentTime == 0))) {
+    if (this.video_.paused && (this.video_.currentTime != this.startTime_ ||
+      (!this.video_.autoplay && this.video_.currentTime == this.startTime_))) {
       return;
     }
 
@@ -228,6 +243,13 @@ shaka.media.GapJumpingController = class {
     }
 
     this.video_.currentTime = jumpTo;
+    // This accounts for the possibility that we jump a gap at the start
+    // position but we jump _into_ another gap. By setting the start
+    // position to the new jumpTo we ensure that the check above will
+    // pass even though the video is still paused.
+    if (currentTime == this.startTime_) {
+      this.startTime_ = jumpTo;
+    }
     this.gapsJumped_++;
     this.onEvent_(
         new shaka.util.FakeEvent(shaka.util.FakeEvent.EventName.GapJumped));

package/lib/media/media_source_engine.js

@@ -529,11 +529,13 @@ shaka.media.MediaSourceEngine = class {
    * @param {boolean=} seeked True if we just seeked
    * @param {boolean=} adaptation True if we just automatically switched active
    *   variant(s).
+   * @param {boolean=} isChunkedData True if we add to the buffer from the
+   *   partial read of the segment.
    * @return {!Promise}
    */
   async appendBuffer(
       contentType, data, reference, hasClosedCaptions, seeked = false,
-      adaptation = false) {
+      adaptation = false, isChunkedData = false) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     if (contentType == ContentType.TEXT) {
@@ -706,13 +708,13 @@ shaka.media.MediaSourceEngine = class {
     let bufferedBefore = null;
 
     await this.enqueueOperation_(contentType, () => {
-      if (goog.DEBUG && reference) {
+      if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
         bufferedBefore = this.getBuffered_(contentType);
       }
       this.append_(contentType, data);
     });
 
-    if (goog.DEBUG && reference && !reference.isPreload()) {
+    if (goog.DEBUG && reference && !reference.isPreload() && !isChunkedData) {
       const bufferedAfter = this.getBuffered_(contentType);
       const newBuffered = shaka.media.TimeRangesUtils.computeAddedRange(
           bufferedBefore, bufferedAfter);

package/lib/media/playhead.js

@@ -251,6 +251,7 @@ shaka.media.MediaSourcePlayhead = class {
     this.videoWrapper_ = new shaka.media.VideoWrapper(
         mediaElement,
         () => this.onSeeking_(),
+        (realStartTime) => this.onStarted_(realStartTime),
         this.getStartTime_(startTime));
 
     /** @type {shaka.util.Timer} */
@@ -390,6 +391,16 @@ shaka.media.MediaSourcePlayhead = class {
     }
   }
 
+  /**
+   * Called when the video element has started up and is listening for new seeks
+   *
+   * @param {number} startTime
+   * @private
+   */
+  onStarted_(startTime) {
+    this.gapController_.onStarted(startTime);
+  }
+
   /**
    * Handles when a seek happens on the video.
    *

package/lib/media/region_observer.js

@@ -27,13 +27,24 @@ shaka.media.RegionObserver = class extends shaka.util.FakeEventTarget {
    * destroy the timeline.
    *
    * @param {!shaka.media.RegionTimeline} timeline
+   * @param {boolean} startsPastZero
    */
-  constructor(timeline) {
+  constructor(timeline, startsPastZero) {
     super();
 
     /** @private {shaka.media.RegionTimeline} */
     this.timeline_ = timeline;
 
+    /**
+     * Whether the asset is expected to start at a time beyond 0 seconds.
+     * For example, if the asset is a live stream.
+     * If true, we will not start polling for regions until the playhead has
+     * moved past 0 seconds, to avoid bad behaviors where the current time is
+     * briefly 0 before we have enough data to play.
+     * @private {boolean}
+     */
+    this.startsPastZero_ = startsPastZero;
+
     /**
      * A mapping between a region and where we previously were relative to it.
      * When the value here differs from what we calculate, it means we moved and
@@ -121,6 +132,13 @@ shaka.media.RegionObserver = class extends shaka.util.FakeEventTarget {
   /** @override */
   poll(positionInSeconds, wasSeeking) {
     const RegionObserver = shaka.media.RegionObserver;
+    if (this.startsPastZero_ && positionInSeconds == 0) {
+      // Don't start checking regions until the timeline has begun moving.
+      return;
+    }
+    // Now that we have seen the playhead go past 0, it's okay if it goes
+    // back there (e.g. seeking back to the start).
+    this.startsPastZero_ = false;
 
     for (const region of this.timeline_.regions()) {
       const previousPosition = this.oldPosition_.get(region);

package/lib/media/streaming_engine.js

@@ -1308,7 +1308,8 @@ shaka.media.StreamingEngine = class {
             const dataToAppend = remaining.subarray(0, offset);
             remaining = remaining.subarray(offset);
             await this.append_(
-                mediaState, presentationTime, stream, reference, dataToAppend);
+                mediaState, presentationTime, stream, reference, dataToAppend,
+                /* isChunkedData= */ true);
           }
         };
 
@@ -1696,10 +1697,12 @@ shaka.media.StreamingEngine = class {
    * @param {shaka.extern.Stream} stream
    * @param {!shaka.media.SegmentReference} reference
    * @param {BufferSource} segment
+   * @param {boolean=} isChunkedData
    * @return {!Promise}
    * @private
    */
-  async append_(mediaState, presentationTime, stream, reference, segment) {
+  async append_(mediaState, presentationTime, stream, reference, segment,
+      isChunkedData = false) {
     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
 
     const hasClosedCaptions = stream.closedCaptions &&
@@ -1732,7 +1735,8 @@ shaka.media.StreamingEngine = class {
         reference,
         hasClosedCaptions,
         seeked,
-        adaptation);
+        adaptation,
+        isChunkedData);
     this.destroyer_.ensureNotDestroyed();
     shaka.log.v2(logPrefix, 'appended media segment');
   }

package/lib/media/video_wrapper.js

@@ -27,15 +27,19 @@ shaka.media.VideoWrapper = class {
   /**
    * @param {!HTMLMediaElement} video
    * @param {function()} onSeek Called when the video seeks.
+   * @param {function(number)} onStarted Called when the video has started.
    * @param {number} startTime The time to start at.
    */
-  constructor(video, onSeek, startTime) {
+  constructor(video, onSeek, onStarted, startTime) {
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 
     /** @private {function()} */
     this.onSeek_ = onSeek;
 
+    /** @private {function(number)} */
+    this.onStarted_ = onStarted;
+
     /** @private {number} */
     this.startTime_ = startTime;
 
@@ -165,6 +169,7 @@ shaka.media.VideoWrapper = class {
     this.started_ = true;
 
     this.eventManager_.listen(this.video_, 'seeking', () => this.onSeek_());
+    this.onStarted_(this.video_.currentTime);
   }
 };
 

package/lib/player.js

@@ -1996,7 +1996,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.abrManager_.setMediaElement(mediaElement);
 
     this.playhead_ = this.createPlayhead(has.startTime);
-    this.playheadObservers_ = this.createPlayheadObserversForMSE_();
+    this.playheadObservers_ =
+        this.createPlayheadObserversForMSE_(has.startTimeOfLoad);
 
     // We need to start the buffer management code near the end because it will
     // set the initial buffering state and that depends on other components
@@ -2761,17 +2762,21 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * Create the observers for MSE playback. These observers are responsible for
    * notifying the app and player of specific events during MSE playback.
    *
+   * @param {number} startTimeOfLoad
    * @return {!shaka.media.PlayheadObserverManager}
    * @private
    */
-  createPlayheadObserversForMSE_() {
+  createPlayheadObserversForMSE_(startTimeOfLoad) {
     goog.asserts.assert(this.manifest_, 'Must have manifest');
     goog.asserts.assert(this.regionTimeline_, 'Must have region timeline');
     goog.asserts.assert(this.video_, 'Must have video element');
 
+    const startsPastZero = this.isLive() || startTimeOfLoad > 0;
+
     // Create the region observer. This will allow us to notify the app when we
     // move in and out of timeline regions.
-    const regionObserver = new shaka.media.RegionObserver(this.regionTimeline_);
+    const regionObserver = new shaka.media.RegionObserver(
+        this.regionTimeline_, startsPastZero);
 
     regionObserver.addEventListener('enter', (event) => {
       /** @type {shaka.extern.TimelineRegionInfo} */
@@ -6630,7 +6635,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.2.11-uncompiled';
+shaka.Player.version = 'v4.2.12-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/abort_controller.js

@@ -86,6 +86,13 @@ class extends shaka.util.FakeEventTarget {
     return this.reason_;
   }
 
+  /** @return {void} */
+  throwIfAborted() {
+    if (this.aborted_) {
+      throw this.reason_;
+    }
+  }
+
   /**
    * @param {*} reason
    * @private

package/lib/text/vtt_text_parser.js

@@ -785,7 +785,8 @@ shaka.text.VttTextParser = class {
     } else if ((results = /^size:([\d.]+)%$/.exec(word))) {
       cue.size = Number(results[1]);
     } else if ((results =
-        /^position:([\d.]+)%(?:,(line-left|line-right|center|start|end))?$/
+        // eslint-disable-next-line max-len
+        /^position:([\d.]+)%(?:,(line-left|line-right|middle|center|start|end))?$/
             .exec(word))) {
       cue.position = Number(results[1]);
       if (results[2]) {

package/lib/util/manifest_parser_utils.js

@@ -168,7 +168,7 @@ shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_ = [
   /^hvc/,
   /^vp0?[89]/,
   /^av01/,
-  /^dvhe/,
+  /^dvh/,
 ];
 
 

package/lib/util/mp4_box_parsers.js

@@ -112,10 +112,11 @@ shaka.util.Mp4BoxParsers = class {
   static parseTRUN(reader, version, flags) {
     const sampleCount = reader.readUint32();
     const sampleData = [];
+    let dataOffset = null;
 
-    // Skip "data_offset" if present.
+    // "data_offset"
     if (flags & 0x000001) {
-      reader.skip(4);
+      dataOffset = reader.readUint32();
     }
 
     // Skip "first_sample_flags" if present.
@@ -159,6 +160,7 @@ shaka.util.Mp4BoxParsers = class {
     return {
       sampleCount,
       sampleData,
+      dataOffset,
     };
   }
 
@@ -252,13 +254,16 @@ shaka.util.ParsedTREXBox;
 /**
  * @typedef {{
  *    sampleCount: number,
- *    sampleData: !Array.<shaka.util.ParsedTRUNSample>
+ *    sampleData: !Array.<shaka.util.ParsedTRUNSample>,
+ *    dataOffset: ?number
  * }}
  *
  * @property {number} sampleCount
  *   As per the spec: the number of samples being added in this run;
  * @property {!Array.<shaka.util.ParsedTRUNSample>} sampleData
  *   An array of size <sampleCount> containing data for each sample
+ * @property {?number} dataOffset
+ *   If specified via flags, this indicate the offset of the sample in bytes.
  *
  * @exportDoc
  */