feat(BREAKING): use bigint for 64 bit ints if needed and available.

lib/mp4/caption-parser.js

@@ -15,6 +15,7 @@ var findBox = require('../mp4/find-box.js');
 var parseTfdt = require('../tools/parse-tfdt.js');
 var parseTrun = require('../tools/parse-trun.js');
 var parseTfhd = require('../tools/parse-tfhd.js');
+var window = require('global/window');
 
 /**
  * Maps an offset in the mdat to a sample based on the the size of the samples.
@@ -122,7 +123,7 @@ var findSeiNals = function(avcStream, samples, trackId) {
  * the absolute presentation and decode timestamps of each sample.
  *
  * @param {Array<Uint8Array>} truns - The Trun Run boxes to be parsed
- * @param {Number} baseMediaDecodeTime - base media decode time from tfdt
+ * @param {Number|BigInt} baseMediaDecodeTime - base media decode time from tfdt
  @see ISO-BMFF-12/2015, Section 8.8.12
  * @param {Object} tfhd - The parsed Track Fragment Header
  * @see inspect.parseTfhd
@@ -156,9 +157,15 @@ var parseSamples = function(truns, baseMediaDecodeTime, tfhd) {
  if (sample.compositionTimeOffset === undefined) {
  sample.compositionTimeOffset = 0;
  }
- sample.pts = currentDts + sample.compositionTimeOffset;
 
- currentDts += sample.duration;
+ if (typeof currentDts === 'bigint') {
+ sample.pts = currentDts + window.BigInt(sample.compositionTimeOffset);
+ currentDts += window.BigInt(sample.duration);
+
+ } else {
+ sample.pts = currentDts + sample.compositionTimeOffset;
+ currentDts += sample.duration;
+ }
  });
 
  allSamples = allSamples.concat(samples);

lib/mp4/mp4-generator.js

@@ -9,7 +9,8 @@
  */
 'use strict';
 
-var UINT32_MAX = Math.pow(2, 32) - 1;
+var MAX_UINT32 = require('../utils/numbers.js').MAX_UINT32;
+
 
 var box, dinf, esds, ftyp, mdat, mfhd, minf, moof, moov, mvex, mvhd,
  trak, tkhd, mdia, mdhd, hdlr, sdtp, stbl, stsd, traf, trex,
@@ -581,8 +582,8 @@ traf = function(track) {
  0x00, 0x00, 0x00, 0x00 // default_sample_flags
  ]));
 
- upperWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime / (UINT32_MAX + 1));
- lowerWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime % (UINT32_MAX + 1));
+ upperWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime / (MAX_UINT32));
+ lowerWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime % (MAX_UINT32));
 
  trackFragmentDecodeTime = box(types.tfdt, new Uint8Array([
  0x01, // version 1

lib/mp4/probe.js

@@ -15,8 +15,11 @@ var parseType = require('../mp4/parse-type.js');
 var parseTfhd = require('../tools/parse-tfhd.js');
 var parseTrun = require('../tools/parse-trun.js');
 var parseTfdt = require('../tools/parse-tfdt.js');
+var getUint64 = require('../utils/numbers.js').getUint64;
 var timescale, startTime, compositionStartTime, getVideoTrackIds, getTracks,
  getTimescaleFromMediaHeader;
+var window = require('global/window');
+
 
 /**
  * Parses an MP4 initialization segment and extracts the timescale
@@ -87,52 +90,55 @@ timescale = function(init) {
  * fragment, in seconds
  */
 startTime = function(timescale, fragment) {
- var trafs, baseTimes, result;
+ var trafs, result;
 
  // we need info from two childrend of each track fragment box
  trafs = findBox(fragment, ['moof', 'traf']);
 
  // determine the start times for each track
- baseTimes = [].concat.apply([], trafs.map(function(traf) {
- return findBox(traf, ['tfhd']).map(function(tfhd) {
- var id, scale, baseTime;
-
- // get the track id from the tfhd
- id = toUnsigned(tfhd[4] << 24 |
- tfhd[5] << 16 |
- tfhd[6] << 8 |
- tfhd[7]);
- // assume a 90kHz clock if no timescale was specified
- scale = timescale[id] || 90e3;
-
- // get the base media decode time from the tfdt
- baseTime = findBox(traf, ['tfdt']).map(function(tfdt) {
- var version, result;
-
- version = tfdt[0];
- result = toUnsigned(tfdt[4] << 24 |
- tfdt[5] << 16 |
- tfdt[6] << 8 |
- tfdt[7]);
- if (version === 1) {
- result *= Math.pow(2, 32);
- result += toUnsigned(tfdt[8] << 24 |
- tfdt[9] << 16 |
- tfdt[10] << 8 |
- tfdt[11]);
- }
- return result;
- })[0];
- baseTime = typeof baseTime === 'number' && !isNaN(baseTime) ? baseTime : Infinity;
+ var lowestTime = trafs.reduce(function(acc, traf) {
+ var tfhd = findBox(traf, ['tfhd'])[0];
+
+ // get the track id from the tfhd
+ var id = toUnsigned(tfhd[4] << 24 |
+ tfhd[5] << 16 |
+ tfhd[6] << 8 |
+ tfhd[7]);
+ // assume a 90kHz clock if no timescale was specified
+ var scale = timescale[id] || 90e3;
+
+ // get the base media decode time from the tfdt
+ var tfdt = findBox(traf, ['tfdt'])[0];
+ var dv = new DataView(tfdt.buffer, tfdt.byteOffset, tfdt.byteLength);
+ var baseTime;
+
+ // version 1 is 64 bit
+ if (tfdt[0] === 1) {
+ baseTime = getUint64(tfdt.subarray(4, 12));
+ } else {
+ baseTime = dv.getUint32(4);
+ }
 
- // convert base time to seconds
- return baseTime / scale;
- });
- }));
+ // convert base time to seconds if it is a valid number.
+ let seconds;
+ if (typeof baseTime === 'bigint') {
+ seconds = baseTime / window.BigInt(scale);
+ } else if (typeof baseTime === 'number' && !isNaN(baseTime)) {
+ seconds = baseTime / scale;
+ }
+
+ if (seconds < Number.MAX_SAFE_INTEGER) {
+ seconds = Number(seconds);
+ }
 
- // return the minimum
- result = Math.min.apply(null, baseTimes);
- return isFinite(result) ? result : 0;
+ if (seconds < acc) {
+ acc = seconds;
+ }
+
+ return acc;
+ }, Infinity);
+
+ return typeof lowestTime === 'bigint' || isFinite(lowestTime) ? lowestTime : 0;
 };
 
 /**
@@ -194,7 +200,18 @@ compositionStartTime = function(timescales, fragment) {
  var timescale = timescales[trackId] || 90e3;
 
  // return the composition start time, in seconds
- return (baseMediaDecodeTime + compositionTimeOffset) / timescale;
+ if (typeof baseMediaDecodeTime === 'bigint') {
+ compositionTimeOffset = window.BigInt(compositionTimeOffset);
+ timescale = window.BigInt(timescale);
+ }
+
+ var result = (baseMediaDecodeTime + compositionTimeOffset) / timescale;
+
+ if (typeof result === 'bigint' && result < Number.MAX_SAFE_INTEGER) {
+ result = Number(result);
+ }
+
+ return result;
 };
 
 /**

lib/tools/mp4-inspector.js

@@ -9,7 +9,9 @@
  */
 'use strict';
 
-var MAX_UINT32 = Math.pow(2, 32);
+var numberHelpers = require('../utils/numbers.js');
+var MAX_UINT32 = numberHelpers.MAX_UINT32;
+var getUint64 = numberHelpers.getUint64;
 
 var
  inspectMp4,
@@ -150,8 +152,8 @@ var
  i += 12;
  } else {
  result.edits.push({
- segmentDuration: (view.getUint32(i) * MAX_UINT32) + view.getUint32(i + 4),
- mediaTime: (view.getUint32(i + 8) * MAX_UINT32) + view.getUint32(i + 12),
+ segmentDuration: getUint64(data.subarray(i)),
+ mediaTime: getUint64(data.subarray(i + 8)),
  mediaRate: view.getUint16(i + 16) + view.getUint16(i + 18) / (256 * 256)
  });
  i += 20;

lib/tools/parse-sidx.js

@@ -1,4 +1,4 @@
-var MAX_UINT32 = Math.pow(2, 32);
+var getUint64 = require('../utils/numbers.js').getUint64;
 
 var parseSidx = function(data) {
  var view = new DataView(data.buffer, data.byteOffset, data.byteLength),
@@ -17,8 +17,8 @@ var parseSidx = function(data) {
  i += 8;
  } else {
  // read 64 bits
- result.earliestPresentationTime = (view.getUint32(i) * MAX_UINT32) + view.getUint32(i + 4);
- result.firstOffset = (view.getUint32(i + 8) * MAX_UINT32) + view.getUint32(i + 12);
+ result.earliestPresentationTime = getUint64(data.subarray(i));
+ result.firstOffset = getUint64(data.subarray(i + 8));
  i += 16;
  }
 

lib/tools/parse-tfdt.js

@@ -1,14 +1,17 @@
 var toUnsigned = require('../utils/bin').toUnsigned;
+var getUint64 = require('../utils/numbers.js').getUint64;
 
 var tfdt = function(data) {
  var result = {
  version: data[0],
  flags: new Uint8Array(data.subarray(1, 4)),
- baseMediaDecodeTime: toUnsigned(data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7])
  };
+
+
  if (result.version === 1) {
- result.baseMediaDecodeTime *= Math.pow(2, 32);
- result.baseMediaDecodeTime += toUnsigned(data[8] << 24 | data[9] << 16 | data[10] << 8 | data[11]);
+ result.baseMediaDecodeTime = getUint64(data.subarray(4));
+ } else {
+ result.baseMediaDecodeTime = toUnsigned(data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7])
  }
  return result;
 };

lib/utils/numbers.js

@@ -0,0 +1,23 @@
+var MAX_UINT32 = Math.pow(2, 32);
+
+var getUint64 = (uint8) => {
+ var dv = new DataView(uint8.buffer, uint8.byteOffset, uint8.byteLength);
+ var value;
+
+ if (dv.getBigUint64) {
+ value = dv.getBigUint64(0);
+
+ if (value < Number.MAX_SAFE_INTEGER) {
+ return Number(value);
+ }
+
+ return value;
+ }
+
+ return (dv.getUint32(0) * MAX_UINT32) + dv.getUint32(4);
+};
+
+module.exports = {
+ getUint64: getUint64,
+ MAX_UINT32: MAX_UINT32
+};