shaka-player 4.3.0 → 4.3.2

package/test/polyfill/media_capabilities_unit.js

@@ -0,0 +1,259 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('MediaCapabilities', () => {
+  const Util = shaka.test.Util;
+  const originalCast = window['cast'];
+  const originalVendor = navigator.vendor;
+  const originalUserAgent = navigator.userAgent;
+  const originalRequestMediaKeySystemAccess =
+    navigator.requestMediaKeySystemAccess;
+  const originalMediaCapabilities = navigator.mediaCapabilities;
+  const supportMap = shaka.media.Capabilities.MediaSourceTypeSupportMap;
+
+  /** @type {MediaDecodingConfiguration} */
+  let mockDecodingConfig;
+  /** @type {!jasmine.Spy} */
+  let mockCanDisplayType;
+
+  beforeAll(() => {
+    Object.defineProperty(window['navigator'],
+        'userAgent', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'vendor', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'requestMediaKeySystemAccess', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'mediaCapabilities', {
+          value: undefined, configurable: true,
+          writable: true,
+        });
+  });
+
+  beforeEach(() => {
+    mockDecodingConfig = {
+      audio: {
+        bitrate: 100891,
+        channels: 2,
+        contentType: 'audio/mp4; codecs="mp4a.40.2"',
+        samplerate: 48000,
+        spatialRendering: false,
+      },
+      keySystemConfiguration: {
+        audio: {robustness: 'SW_SECURE_CRYPTO'},
+        distinctiveIdentifier: 'optional',
+        initDataType: 'cenc',
+        keySystem: 'com.widevine.alpha',
+        persistentState: 'optional',
+        sessionTypes: ['temporary'],
+        video: {robustness: 'SW_SECURE_CRYPTO'},
+      },
+      type: 'media-source',
+      video: {
+        bitrate: 349265,
+        contentType: 'video/mp4; codecs="avc1.4D4015"',
+        framerate: 23.976023976023978,
+        height: 288,
+        width: 512,
+      },
+    };
+    shaka.polyfill.MediaCapabilities.memoizedMediaKeySystemAccessRequests_ = {};
+
+    mockCanDisplayType = jasmine.createSpy('canDisplayType');
+    mockCanDisplayType.and.returnValue(false);
+  });
+
+  afterEach(() => {
+    window['cast'] = originalCast;
+  });
+
+  afterAll(() => {
+    window['cast'] = originalCast;
+    Object.defineProperty(window['navigator'],
+        'userAgent', {value: originalUserAgent});
+    Object.defineProperty(window['navigator'],
+        'vendor', {value: originalVendor});
+    Object.defineProperty(window['navigator'],
+        'requestMediaKeySystemAccess',
+        {value: originalRequestMediaKeySystemAccess});
+    Object.defineProperty(window['navigator'],
+        'mediaCapabilities', {value: originalMediaCapabilities});
+  });
+
+  describe('install', () => {
+    it('should define decoding info method', () => {
+      shaka.polyfill.MediaCapabilities.install();
+
+      expect(navigator.mediaCapabilities.decodingInfo).toBeDefined();
+    });
+  });
+
+  describe('decodingInfo', () => {
+    it('should check codec support when MediaDecodingConfiguration.type ' +
+      'is "media-source"', () => {
+      expect(window['MediaSource']['isTypeSupported']).toBeDefined();
+      shaka.polyfill.MediaCapabilities.install();
+      navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      expect(supportMap.has(mockDecodingConfig.video.contentType)).toBe(true);
+      expect(supportMap.has(mockDecodingConfig.audio.contentType)).toBe(true);
+    });
+
+    it('should check codec support when MediaDecodingConfiguration.type ' +
+      'is "file"', () => {
+      const supportsMediaTypeSpy =
+          spyOn(shaka['util']['Platform'],
+              'supportsMediaType').and.returnValue(true);
+      mockDecodingConfig.type = 'file';
+      shaka.polyfill.MediaCapabilities.install();
+      navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      expect(supportsMediaTypeSpy).toHaveBeenCalledTimes(2);
+      expect(supportsMediaTypeSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.video.contentType,
+      );
+      expect(supportsMediaTypeSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.audio.contentType,
+      );
+    });
+
+    it('should check MediaKeySystem when keySystemConfiguration is present',
+        async () => {
+          const mockResult = {mockKeySystemAccess: 'mockKeySystemAccess'};
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+          const requestKeySystemAccessSpy =
+          spyOn(window['navigator'],
+              'requestMediaKeySystemAccess').and.returnValue(mockResult);
+
+          shaka.polyfill.MediaCapabilities.install();
+          const result = await navigator.mediaCapabilities
+              .decodingInfo(mockDecodingConfig);
+
+          expect(requestKeySystemAccessSpy).toHaveBeenCalledWith(
+              'com.widevine.alpha',
+              [{
+                audioCapabilities: [
+                  {
+                    robustness: 'SW_SECURE_CRYPTO',
+                    contentType: 'audio/mp4; codecs="mp4a.40.2"',
+                  },
+                ],
+                distinctiveIdentifier: 'optional',
+                initDataTypes: ['cenc'],
+                persistentState: 'optional',
+                sessionTypes: ['temporary'],
+                videoCapabilities: [{
+                  robustness: 'SW_SECURE_CRYPTO',
+                  contentType: 'video/mp4; codecs="avc1.4D4015"',
+                }],
+              }],
+          );
+          expect(result.keySystemAccess).toEqual(mockResult);
+        });
+
+    it('throws when the cast namespace is not available', async () => {
+      // Temporarily remove window.cast to trigger error. It's restored after
+      // every test.
+      delete window['cast'];
+
+      const isChromecastSpy =
+          spyOn(shaka['util']['Platform'],
+              'isChromecast').and.returnValue(true);
+      const expected = Util.jasmineError(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.CAST,
+          shaka.util.Error.Code.CAST_API_UNAVAILABLE));
+      const isTypeSupportedSpy =
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+
+      shaka.polyfill.MediaCapabilities.install();
+      await expectAsync(
+          navigator.mediaCapabilities.decodingInfo(mockDecodingConfig))
+          .toBeRejectedWith(expected);
+
+      expect(isTypeSupportedSpy).not.toHaveBeenCalled();
+      // 1 (during install()) + 1 (for video config check).
+      expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('falls back to isTypeSupported() when canDisplayType() missing',
+        async () => {
+          // We only set the cast namespace, but not the canDisplayType() API.
+          window['cast'] = {};
+          const isChromecastSpy =
+              spyOn(shaka['util']['Platform'],
+                  'isChromecast').and.returnValue(true);
+          expect(window['MediaSource']['isTypeSupported']).toBeDefined();
+
+          shaka.polyfill.MediaCapabilities.install();
+          await navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+          expect(mockCanDisplayType).not.toHaveBeenCalled();
+          // 1 (during install()) + 1 (for video config check).
+          expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+          // 1 (fallback in canCastDisplayType()) +
+          // 1 (mockDecodingConfig.audio).
+          expect(supportMap.has(mockDecodingConfig.video.contentType))
+              .toBe(true);
+          expect(supportMap.has(mockDecodingConfig.audio.contentType))
+              .toBe(true);
+        });
+
+    it('should use cast.__platform__.canDisplayType for "supported" field ' +
+        'when platform is Cast', async () => {
+      // We're using quotes to access window.cast because the compiler
+      // knows about lots of Cast-specific APIs we aren't mocking.  We
+      // don't need this mock strictly type-checked.
+      window['cast'] = {
+        __platform__: {canDisplayType: mockCanDisplayType},
+      };
+      const isChromecastSpy =
+          spyOn(shaka['util']['Platform'],
+              'isChromecast').and.returnValue(true);
+      expect(window['MediaSource']['isTypeSupported']).toBeDefined();
+
+      // Tests an HDR stream's extended MIME type is correctly provided.
+      mockDecodingConfig.video.transferFunction = 'pq';
+      mockDecodingConfig.video.contentType =
+          'video/mp4; codecs="hev1.2.4.L153.B0"';
+      // Round to a whole number since we can't rely on number => string
+      // conversion precision on all devices.
+      mockDecodingConfig.video.framerate = 24;
+
+      const chromecastType =
+          'video/mp4; ' +
+          'codecs="hev1.2.4.L153.B0"; ' +
+          'width=512; ' +
+          'height=288; ' +
+          'framerate=24; ' +
+          'eotf=smpte2084';
+      mockCanDisplayType.and.callFake((type) => {
+        expect(type).toBe(chromecastType);
+        supportMap.set(type, true);
+        return true;
+      });
+
+      shaka.polyfill.MediaCapabilities.install();
+      await navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      // 1 (during install()) + 1 (for video config check).
+      expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+      // 1 (mockDecodingConfig.audio).
+      expect(supportMap.has(chromecastType)).toBe(true);
+      // Called once in canCastDisplayType.
+      expect(mockCanDisplayType).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/test/polyfill/patchedmediakeys_apple_unit.js

@@ -1,3 +1,9 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 describe('PatchedMediaKeys_Apple', () => {
   const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
   let originalMediaKeys;

package/test/test/boot.js

@@ -66,22 +66,40 @@ function failTestsOnNamespacedElementOrAttributeNames() {
 }
 
 /**
- * Listen for unhandled Promise rejections (which may occur after a test) and
- * convert them into test failures.
+ * Fail the current test on a given error, constructed with a given header and
+ * the full stack trace of the error.
+ *
+ * @param {string} messageHeader
+ * @param {!Error} error
  */
-function failTestsOnUnhandledRejections() {
+function failOnError(messageHeader, error) {
+  let message = `${messageHeader}: ${error}`;
+  // Shaka errors have the stack trace in their toString() already, so don't
+  // add it again.  For native errors, we need to see where it came from.
+  if (error && error.stack && !(error instanceof shaka.util.Error)) {
+    message += '\n' + error.stack;
+  }
+  fail(message);
+}
+
+/**
+ * Listen for unhandled errors and Promise rejections (which may occur after a
+ * test) and convert them into test failures.
+ */
+function failTestsOnUnhandledErrors() {
   // https://developer.mozilla.org/en-US/docs/Web/Events/unhandledrejection
   window.addEventListener('unhandledrejection', (event) => {
     /** @type {?} */
     const error = event.reason;
-    let message = 'Unhandled rejection in Promise: ' + error;
+    failOnError('Unhandled rejection in Promise', error);
+  });
 
-    // Shaka errors have the stack trace in their toString() already, so don't
-    // add it again.  For native errors, we need to see where it came from.
-    if (error && error.stack && !(error instanceof shaka.util.Error)) {
-      message += '\n' + error.stack;
-    }
-    fail(message);
+  // https://developer.mozilla.org/en-US/docs/Web/API/Window/error_event
+  // https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
+  window.addEventListener('error', (event) => {
+    /** @type {?} */
+    const error = event['error'];
+    failOnError('Unhandled error', error);
   });
 }
 
@@ -387,7 +405,7 @@ function configureJasmineEnvironment() {
 function setupTestEnvironment() {
   failTestsOnFailedAssertions();
   failTestsOnNamespacedElementOrAttributeNames();
-  failTestsOnUnhandledRejections();
+  failTestsOnUnhandledErrors();
   disableScrollbars();
   workAroundLegacyEdgePromiseIssues();
 

package/test/test/util/manifest_parser_util.js

@@ -73,7 +73,7 @@ shaka.test.ManifestParser = class {
     const appendWindowStart = /** @type {?} */(jasmine.any(Number));
     const appendWindowEnd = /** @type {?} */(jasmine.any(Number));
 
-    return new shaka.media.SegmentReference(
+    const ref = new shaka.media.SegmentReference(
         start, end, getUris, startByte, endByte,
         initSegmentReference,
         timestampOffset,
@@ -82,7 +82,8 @@ shaka.test.ManifestParser = class {
         partialReferences,
         tilesLayout,
         /* tileDuration= */ undefined,
-        syncTime,
-    );
+        syncTime);
+    ref.discontinuitySequence = /** @type {?} */(jasmine.any(Number));
+    return ref;
   }
 };

package/test/test/util/stream_generator.js

@@ -51,19 +51,36 @@ shaka.test.IStreamGenerator = class {
  * @implements {shaka.test.IStreamGenerator}
  */
 shaka.test.TSVodStreamGenerator = class {
-  /** @param {string} segmentUri The URI of the segment. */
-  constructor(segmentUri) {
+  /**
+   * @param {string} segmentUri The URI of the segment.
+   * @param {number} segmentDuration The duration of a single segment, in
+   *   seconds.
+   */
+  constructor(segmentUri, segmentDuration) {
     /** @private {string} */
     this.segmentUri_ = segmentUri;
 
+    /**
+     * Internally, everything is in timescale units.
+     * @private {number}
+     */
+    this.segmentDuration_ = segmentDuration * 90000;
+
+    /** @private {!Array.<{offset: number, dts: ?number, pts: ?number}>} */
+    this.timestamps_ = [];
+
+    /** @private {number} */
+    this.timestampOffset_ = Infinity;
+
     /** @private {ArrayBuffer} */
-    this.segment_ = null;
+    this.segmentTemplate_ = null;
   }
 
   /** @override */
   async init() {
     const segment = await shaka.test.Util.fetch(this.segmentUri_);
-    this.segment_ = segment;
+    this.segmentTemplate_ = segment;
+    this.parseSegment_();
   }
 
   /** @override */
@@ -75,11 +92,198 @@ shaka.test.TSVodStreamGenerator = class {
   /** @override */
   getSegment(position, wallClockTime) {
     goog.asserts.assert(
-        this.segment_,
+        this.segmentTemplate_,
         'init() must be called before getSegment().');
-    // TODO: complete implementation; this should change the timestamps based on
-    // the given wallClockTime, so as to simulate a long stream.
-    return this.segment_;
+
+    // This will create a copy of the given buffer.
+    const buffer = shaka.util.Uint8ArrayUtils.concat(this.segmentTemplate_);
+
+    for (const timestampMetadata of this.timestamps_) {
+      this.setTimestamp_(buffer, timestampMetadata, position);
+    }
+
+    return shaka.util.BufferUtils.toArrayBuffer(buffer);
+  }
+
+  /** @private */
+  parseSegment_() {
+    goog.asserts.assert(
+        this.segmentTemplate_,
+        'init() must be called before parseSegment_().');
+
+    // A TS segment can contain a timestamp in each 188-byte PES packet.
+    // Find all the timestamps and their offsets, and cache them.
+    const dataView = shaka.util.BufferUtils.toDataView(this.segmentTemplate_);
+    const reader = new shaka.util.DataViewReader(
+        dataView, shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
+
+    // Read each TS packet (188 bytes).
+    for (let i = 0; i < reader.getLength(); i += 188) {
+      reader.seek(i);
+      const syncByte = reader.readUint8();
+      goog.asserts.assert(syncByte == 0x47, 'Sync byte not found!');
+
+      const flagsAndPacketId = reader.readUint16();
+      const packetId = flagsAndPacketId & 0x1fff;
+      if (packetId == 0x1fff) {
+        // A "null" TS packet.  Skip it.
+        continue;
+      }
+
+      const hasPesPacket = flagsAndPacketId & 0x4000;
+      if (!hasPesPacket) {
+        // Not a PES packet.  Skip it.
+        continue;
+      }
+
+      const flags = reader.readUint8();
+      const adaptationFieldControl = (flags & 0x30) >> 4;
+      if (adaptationFieldControl == 0 /* reserved */ ||
+          adaptationFieldControl == 2 /* adaptation field, no payload */) {
+        throw new Error(
+            `Unexpected adaptation field control: ${adaptationFieldControl}`);
+      }
+
+      if (adaptationFieldControl == 3) {
+        // Skip over adaptation field.
+        const length = reader.readUint8();
+        reader.skip(length);
+      }
+
+      // Now we come to the PES header (hopefully).
+      // Format reference: https://bit.ly/TsPES
+      const startCode = reader.readUint32();
+      const startCodePrefix = startCode >> 8;
+      if (startCodePrefix != 1) {
+        // Not a PES packet.  Skip it.
+        continue;
+      }
+
+      // Skip the 16-bit PES length and the first 8 bits of the optional header.
+      reader.skip(3);
+      // The next 8 bits contain flags about DTS & PTS.
+      const ptsDtsIndicator = reader.readUint8() >> 6;
+      if (ptsDtsIndicator == 0 /* no timestamp */ ||
+          ptsDtsIndicator == 1 /* forbidden */) {
+        throw new Error(`Unexpected PTS/DTS flag: ${ptsDtsIndicator}`);
+      }
+
+      const pesHeaderLengthRemaining = reader.readUint8();
+      if (pesHeaderLengthRemaining == 0) {
+        throw new Error(`Malformed TS, no room for PTS/DTS!`);
+      }
+
+      const offset = reader.getPosition();
+      let pts = null;
+      let dts = null;
+
+      // Parse timestamps and keep track of the minimum timestamp seen, to use
+      // as a timestamp offset when we calculate new timestamps for a segment.
+      if (ptsDtsIndicator == 2 /* PTS only */) {
+        goog.asserts.assert(pesHeaderLengthRemaining == 5, 'Bad PES header?');
+        pts = this.parseTimestamp_(reader);
+        this.timestampOffset_ = Math.min(this.timestampOffset_, pts);
+      } else if (ptsDtsIndicator == 3 /* PTS and DTS */) {
+        goog.asserts.assert(pesHeaderLengthRemaining == 10, 'Bad PES header?');
+        pts = this.parseTimestamp_(reader);
+        dts = this.parseTimestamp_(reader);
+        this.timestampOffset_ = Math.min(this.timestampOffset_, pts, dts);
+      }
+
+      this.timestamps_.push({
+        offset,
+        pts,
+        dts,
+      });
+    }
+  }
+
+  /**
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {number}
+   * @private
+   */
+  parseTimestamp_(reader) {
+    const pts0 = reader.readUint8();
+    const pts1 = reader.readUint16();
+    const pts2 = reader.readUint16();
+    // Reconstruct 33-bit PTS from the 5-byte, padded structure.
+    const ptsHigh3 = (pts0 & 0x0e) >> 1;
+    const ptsLow30 = ((pts1 & 0xfffe) << 14) | ((pts2 & 0xfffe) >> 1);
+    // Reconstruct the PTS as a float.  Avoid bitwise operations to combine
+    // because bitwise ops treat the values as 32-bit ints.
+    return ptsHigh3 * (1 << 30) + ptsLow30;
+  }
+
+  /**
+   * @param {!Uint8Array} buffer
+   * @param {{offset: number, pts: ?number, dts: ?number}} timestampMetadata
+   * @param {number} position
+   * @private
+   */
+  setTimestamp_(buffer, timestampMetadata, position) {
+    // Wikipedia: "If only PTS is present, this is done by catenating 0010 ...
+    // If both PTS and DTS are present, first 4 bits are 0011 and first 4 bits
+    // for DTS are 0001."
+    const ptsHeader = timestampMetadata.dts == null ? 0b0010 : 0b0011;
+    const dtsHeader = 0b0001;
+
+    const segmentTime = this.segmentDuration_ * position;
+
+    if (timestampMetadata.pts != null) {
+      const pts = timestampMetadata.pts - this.timestampOffset_ + segmentTime;
+      this.writeTimestamp_(
+          buffer, timestampMetadata.offset, ptsHeader, this.overflow_(pts));
+    }
+    if (timestampMetadata.dts != null) {
+      const dts = timestampMetadata.dts - this.timestampOffset_ + segmentTime;
+      this.writeTimestamp_(
+          buffer, timestampMetadata.offset + 5, dtsHeader, this.overflow_(dts));
+    }
+  }
+
+  /**
+   * Write a timestamp (PTS or DTS) to a specific place in the buffer, with a
+   * specific header, in the PES timestamp layout.
+   *
+   * @param {!Uint8Array} buffer
+   * @param {number} offset Where to begin writing
+   * @param {number} header 4-bit header for the timestamp
+   * @param {number} timestamp the actual timestamp
+   * @private
+   */
+  writeTimestamp_(buffer, offset, header, timestamp) {
+    // The 33 bit timestamp is split into parts, then packed into 40 bits
+    // (5 bytes).  Wikipedia phrases the layout as: "0010b, most significant 3
+    // bits from PTS, 1, following next 15 bits, 1, rest 15 bits and 1."
+    // https://en.wikipedia.org/wiki/Packetized_elementary_stream
+    const top3Bits = timestamp >> 30;
+    const next15Bits = (timestamp >> 15) & 0x7fff;
+    const last15Bits = timestamp & 0x7fff;
+
+    buffer[offset + 0] = (header << 4) | (top3Bits << 1) | 1;
+    buffer[offset + 1] = next15Bits >> 7;
+    buffer[offset + 2] = ((next15Bits & 0x7f) << 1) | 1;
+    buffer[offset + 3] = last15Bits >> 7;
+    buffer[offset + 4] = ((last15Bits & 0x7f) << 1) | 1;
+  }
+
+  /**
+   * Handle PES timestamp overflow (33 bits).
+   *
+   * @param {number} timestamp
+   * @return {number}  The same timestamp, with TS overflow applied.
+   * @private
+   */
+  overflow_(timestamp) {
+    // NOTE: You can't get 2^33 with a bit-shift, because JavaScript will treat
+    // the number as a 32-bit int.  Use Math.pow() instead.  The result is
+    // still accurate as an integer.
+    const limit = Math.pow(2, 33);
+    while (timestamp >= limit) {
+      timestamp -= limit;
+    }
+    return timestamp;
   }
 };
 

package/test/test/util/test_scheme.js

@@ -173,7 +173,8 @@ shaka.test.TestScheme = class {
      */
     function createStreamGenerator(metadata) {
       if (metadata.segmentUri.includes('.ts')) {
-        return new shaka.test.TSVodStreamGenerator(metadata.segmentUri);
+        return new shaka.test.TSVodStreamGenerator(
+            metadata.segmentUri, metadata.segmentDuration);
       }
       if (metadata.segmentUri.includes('.aac')) {
         return new shaka.test.AACVodStreamGenerator(metadata.segmentUri);
@@ -412,7 +413,7 @@ const sintelAudioSegment = {
   mdhdOffset: 0x1b6,
   segmentUri: '/base/test/test/assets/sintel-audio-segment.mp4',
   tfdtOffset: 0x3c,
-  segmentDuration: 10.005,
+  segmentDuration: 10,
   mimeType: 'audio/mp4',
   codecs: 'mp4a.40.2',
 };
@@ -438,7 +439,7 @@ const sintelEncryptedAudio = {
   mdhdOffset: 0x1b6,
   segmentUri: '/base/test/test/assets/encrypted-sintel-audio-segment.mp4',
   tfdtOffset: 0x3c,
-  segmentDuration: 10.005,
+  segmentDuration: 10,
   mimeType: 'audio/mp4',
   codecs: 'mp4a.40.2',
   initData:
@@ -634,7 +635,7 @@ shaka.test.TestScheme.DATA = {
       segmentUri: '/base/test/test/assets/captions-test.ts',
       mimeType: 'video/mp2t',
       codecs: 'avc1.64001e',
-      segmentDuration: 2,
+      segmentDuration: 20,  // yes, this is accurate
     },
     text: {
       mimeType: 'application/cea-608',
@@ -661,7 +662,7 @@ shaka.test.TestScheme.DATA = {
       segmentUri: '/base/test/test/assets/id3-metadata.ts',
       mimeType: 'video/mp2t',
       codecs: 'mp4a.40.5',
-      segmentDuration: 4.99,
+      segmentDuration: 5,
     },
     duration: 4.99,
   },

package/test/test/util/util.js

@@ -89,10 +89,11 @@ shaka.test.Util = class {
    * given value.
    *
    * @param {number} val
+   * @param {number=} maxDelta
    * @return {number}
    */
-  static closeTo(val) {
-    const E = 0.000001;
+  static closeTo(val, maxDelta = 0.000001) {
+    const E = /** @type {number} */(maxDelta);
     return /** @type {number} */(/** @type {?} */({
       asymmetricMatch: (other) => other >= val - E && other <= val + E,
       jasmineToString: () => '<closeTo: ' + val + '>',

package/test/text/mp4_ttml_parser_unit.js

@@ -41,7 +41,8 @@ describe('Mp4TtmlParser', () => {
   it('handles media segments with multiple mdats', () => {
     const parser = new shaka.text.Mp4TtmlParser();
     parser.parseInit(ttmlInitSegment);
-    const time = {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0};
+    const time =
+        {periodStart: 0, segmentStart: 0, segmentEnd: 60, vttOffset: 0};
     const ret = parser.parseMedia(ttmlSegmentMultipleMDAT, time);
     // Bodies.
     expect(ret.length).toBe(2);
@@ -55,9 +56,9 @@ describe('Mp4TtmlParser', () => {
 
   it('accounts for offset', () => {
     const time1 =
-        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0};
+        {periodStart: 0, segmentStart: 0, segmentEnd: 70, vttOffset: 0};
     const time2 =
-        {periodStart: 7, segmentStart: 0, segmentEnd: 0, vttOffset: 7};
+        {periodStart: 7, segmentStart: 0, segmentEnd: 70, vttOffset: 7};
 
     const parser = new shaka.text.Mp4TtmlParser();
     parser.parseInit(ttmlInitSegment);
@@ -161,7 +162,8 @@ describe('Mp4TtmlParser', () => {
     ];
     const parser = new shaka.text.Mp4TtmlParser();
     parser.parseInit(ttmlInitSegment);
-    const time = {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0};
+    const time =
+        {periodStart: 0, segmentStart: 0, segmentEnd: 60, vttOffset: 0};
     const result = parser.parseMedia(ttmlSegment, time);
     shaka.test.TtmlUtils.verifyHelper(
         cues, result, {startTime: 23, endTime: 53.5});