shaka-player 4.2.4 → 4.2.5

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

@@ -172,7 +172,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);
       }
       return new shaka.test.Mp4VodStreamGenerator(
           metadata.initSegmentUri, metadata.mdhdOffset, metadata.segmentUri,
@@ -623,7 +624,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',

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