shaka-player 4.2.11 → 4.2.13

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/docs/tutorials/selenium-grid-config.md

@@ -47,17 +47,20 @@ vars:
 FirefoxMac:
   browser: firefox
   os: Mac
-  extra_config: *firefox_config
+  extra_configs:
+    - *firefox_config
 
 FirefoxWindows:
   browser: firefox
   os: Windows
-  extra_config: *firefox_config
+  extra_configs:
+    - *firefox_config
 
 FirefoxLinux:
   browser: firefox
   os: Linux
-  extra_config: *firefox_config
+  extra_configs:
+    - *firefox_config
 ```
 
 ### Browsers
@@ -75,8 +78,8 @@ browser made available to Karma.  Within each of those keys are the following:
        and must match the string and case used in the Selenium node config.
  - `disabled` (optional): If true, this browser is disabled and will not be
        used unless explicitly requested.
- - `extra_config` (optional): A dictionary of extra configs which will be
-       merged with the WebDriver launcher config in Karma.
+ - `extra_configs` (optional): An array of dictionaries of extra configs which
+       will be merged with the WebDriver launcher config in Karma.
 
 Examples of basic desktop browsers definitions:
 
@@ -96,9 +99,9 @@ Safari:
 SafariTP:
   browser: safari
   os: Mac
-  extra_config:
-    safari.options:
-      technologyPreview: true
+  extra_configs:
+    - safari.options:
+        technologyPreview: true
 
 ChromeWindows:
   browser: chrome
@@ -120,3 +123,52 @@ FirefoxLinux:
   browser: firefox
   os: Linux
 ```
+
+### Composing configs
+
+You can define variables for browser configs that can be composed together in
+`extra_configs`.  For example, below you will see some basic definitions for
+Chrome arguments and parameters, and then an additional config with an argument
+that is only needed for some platforms.  `karma.conf.js` will merge those
+argument lists intelligently when it loads the YAML config.
+
+```yaml
+vars:
+  basic_chrome_config: &basic_chrome_config
+    goog:chromeOptions:
+      args:
+        # Normally, Chrome disallows autoplaying videos in many cases.  Enable
+        # it for testing.
+        - "--autoplay-policy=no-user-gesture-required"
+
+      # Instruct chromedriver not to disable component updater.
+      excludeSwitches:
+        - "disable-component-update"
+
+  headless_chrome_config: &headless_chrome_config
+    goog:chromeOptions:
+      args:
+        # Run in headless mode.
+        - "--headless"
+
+ChromeLinux:
+  browser: chrome
+  os: Mac
+  extra_configs:
+    - *basic_chrome_config
+
+ChromeWindows:
+  browser: chrome
+  os: Mac
+  extra_configs:
+    - *basic_chrome_config
+
+ChromeMac:
+  browser: chrome
+  os: Mac
+  # Take the parameters and arguments for basic_chrome_config, then append the
+  # arguments for headless_chrome_config.
+  extra_configs:
+    - *basic_chrome_config
+    - *headless_chrome_config
+```

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/karma.conf.js

@@ -7,9 +7,11 @@
 // Karma configuration
 // Install required modules by running "npm install"
 
-const Jimp = require('jimp');
+// lodash is an indirect dependency, depended on by Karma
+const _ = require('lodash');
 const fs = require('fs');
 const glob = require('glob');
+const Jimp = require('jimp');
 const path = require('path');
 const rimraf = require('rimraf');
 const {ssim} = require('ssim.js');
@@ -17,6 +19,32 @@ const util = require('karma/common/util');
 const which = require('which');
 const yaml = require('js-yaml');
 
+/**
+ * Like Object.assign, but recursive and doesn't clobber objects and arrays.
+ * If two arrays are merged, they are concatenated.
+ * Ex:
+ *   mergeConfigs({ foo: 'bar', args: [1, 2, 3] },
+ *                { baz: 'blah', args: [4, 5, 6] })
+ *       => { foo: 'bar', baz: 'blah', args: [1, 2, 3, 4, 5, 6] }
+ *
+ * @param {Object} first
+ * @param {Object} second
+ * @return {Object}
+ */
+function mergeConfigs(first, second) {
+  return _.mergeWith(
+      first,
+      second,
+      (firstValue, secondValue) => {
+        // Merge arrays by concatenation.
+        if (Array.isArray(firstValue)) {
+          return firstValue.concat(secondValue);
+        }
+        // Use lodash's default merge behavior for everything else.
+        return undefined;
+      });
+}
+
 /**
  * @param {Object} config
  */
@@ -78,7 +106,7 @@ module.exports = (config) => {
       }
 
       // Add standard WebDriver configs.
-      Object.assign(launcher, {
+      mergeConfigs(launcher, {
         base: 'WebDriver',
         config: {hostname: gridHostname, port: gridPort},
         pseudoActivityInterval: 20000,
@@ -87,8 +115,10 @@ module.exports = (config) => {
         version: metadata.version,
       });
 
-      if (metadata.extra_config) {
-        Object.assign(launcher, metadata.extra_config);
+      if (metadata.extra_configs) {
+        for (const config of metadata.extra_configs) {
+          mergeConfigs(launcher, config);
+        }
       }
     }
 
@@ -603,15 +633,27 @@ function WebDriverScreenshotMiddlewareFactory(launcher) {
   }
 
   /**
+   * @param {karma.Launcher.Browser.spec} spec
    * @param {wd.remote} webDriverClient A WebDriver client, an object from the
    *   "wd" package, created by "wd.remote()".
    * @return {!Promise.<!Buffer>} A Buffer containing a PNG screenshot
    */
-  function getScreenshot(webDriverClient) {
+  function getScreenshot(spec, webDriverClient) {
     return new Promise((resolve, reject) => {
       webDriverClient.takeScreenshot((error, pngBase64) => {
         if (error) {
           reject(error);
+        } else if (pngBase64.error) {
+          // In some failure cases, pngBase64 is an object with "error",
+          // "message", and "stacktrace" fields.  This happens, for example,
+          // with a timeout from the screenshot command.  This is not an
+          // expected situation, so log it.  The extra newlines keep this from
+          // being overwritten on the terminal when running tests against many
+          // browsers at once.
+          console.log('\n\nUnexpected screenshot failure:\n' +
+              `  Error: ${JSON.stringify(pngBase64)}\n` +
+              `  WebDriver spec: ${JSON.stringify(spec)}\n\n\n`);
+          reject(pngBase64);
         } else {
           // Convert the screenshot to a binary buffer.
           resolve(Buffer.from(pngBase64, 'base64'));
@@ -635,7 +677,8 @@ function WebDriverScreenshotMiddlewareFactory(launcher) {
     }
 
     /** @type {!Buffer} */
-    const fullPageScreenshotData = await getScreenshot(webDriverClient);
+    const fullPageScreenshotData =
+        await getScreenshot(browser.spec, webDriverClient);
 
     // Crop the screenshot to the dimensions specified in the test.
     // Jimp is picky about types, so convert these strings to numbers.
@@ -754,7 +797,7 @@ function WebDriverScreenshotMiddlewareFactory(launcher) {
         // The result is cached for the sake of performance.
         if (webDriverClient.canTakeScreenshot === undefined) {
           try {
-            await getScreenshot(webDriverClient);
+            await getScreenshot(browser.spec, webDriverClient);
             webDriverClient.canTakeScreenshot = true;
           } catch (error) {
             webDriverClient.canTakeScreenshot = false;

package/lib/abr/simple_abr_manager.js

@@ -48,13 +48,16 @@ shaka.abr.SimpleAbrManager = class {
     /** @private {shaka.abr.EwmaBandwidthEstimator} */
     this.bandwidthEstimator_ = new shaka.abr.EwmaBandwidthEstimator();
 
+    /** @private {?function():void} */
+    this.onNetworkInformationChange_ = null;
+
     // Some browsers implement the Network Information API, which allows
     // retrieving information about a user's network connection. We listen
     // to the change event to be able to make quick changes in case the type
     // 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);
@@ -98,9 +101,6 @@ shaka.abr.SimpleAbrManager = class {
     /** @private {ResizeObserver} */
     this.resizeObserver_ = null;
 
-    /** @private {?function():void} */
-    this.onNetworkInformationChange_ = null;
-
     /** @private {shaka.util.Timer} */
     this.resizeObserverTimer_ = new shaka.util.Timer(() => {
       if (this.config_.restrictToElementSize) {
@@ -175,8 +175,8 @@ shaka.abr.SimpleAbrManager = class {
     if (this.resizeObserver_ && this.config_.restrictToElementSize) {
       const devicePixelRatio =
           this.config_.ignoreDevicePixelRatio ? 1 : window.devicePixelRatio;
-      maxHeight = this.mediaElement_.clientWidth * devicePixelRatio;
-      maxWidth = this.mediaElement_.clientHeight * devicePixelRatio;
+      maxHeight = this.mediaElement_.clientHeight * devicePixelRatio;
+      maxWidth = this.mediaElement_.clientWidth * devicePixelRatio;
     }
 
     // Get sorted Variants.

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);