First release

node_modules/mux.js/test/mp4-generator.test.js

@@ -0,0 +1,581 @@
+'use strict';
+/*
+  ======== A Handy Little QUnit Reference ========
+  http://api.qunitjs.com/
+
+  Test methods:
+  module(name, {[setup][ ,teardown]})
+  QUnit.test(name, callback)
+  expect(numberOfAssertions)
+  stop(increment)
+  start(decrement)
+  Test assertions:
+  assert.ok(value, [message])
+  assert.equal(actual, expected, [message])
+  notEqual(actual, expected, [message])
+  assert.deepEqual(actual, expected, [message])
+  notDeepEqual(actual, expected, [message])
+  assert.strictEqual(actual, expected, [message])
+  notStrictEqual(actual, expected, [message])
+  throws(block, [expected], [message])
+*/
+var
+  mp4 = require('../lib/mp4'),
+  QUnit = require('qunit'),
+  validateMvhd, validateTrak, validateTkhd, validateMdia,
+  validateMdhd, validateHdlr, validateMinf, validateDinf,
+  validateStbl, validateStsd, validateMvex,
+  validateVideoSample, validateAudioSample;
+
+QUnit.module('MP4 Generator');
+
+QUnit.test('generates a BSMFF ftyp', function(assert) {
+  var data = mp4.generator.ftyp(), boxes;
+
+  assert.ok(data, 'box is not null');
+
+  boxes = mp4.tools.inspect(data);
+  assert.equal(1, boxes.length, 'generated a single box');
+  assert.equal(boxes[0].type, 'ftyp', 'generated ftyp type');
+  assert.equal(boxes[0].size, data.byteLength, 'generated size');
+  assert.equal(boxes[0].majorBrand, 'isom', 'major version is "isom"');
+  assert.equal(boxes[0].minorVersion, 1, 'minor version is one');
+});
+
+validateMvhd = function(mvhd) {
+  QUnit.assert.equal(mvhd.type, 'mvhd', 'generated a mvhd');
+  QUnit.assert.equal(mvhd.duration, 0xffffffff, 'wrote the maximum movie header duration');
+  QUnit.assert.equal(mvhd.nextTrackId, 0xffffffff, 'wrote the max next track id');
+};
+
+validateTrak = function(trak, expected) {
+  expected = expected || {};
+  QUnit.assert.equal(trak.type, 'trak', 'generated a trak');
+  QUnit.assert.equal(trak.boxes.length, 2, 'generated two track sub boxes');
+
+  validateTkhd(trak.boxes[0], expected);
+  validateMdia(trak.boxes[1], expected);
+};
+
+validateTkhd = function(tkhd, expected) {
+  QUnit.assert.equal(tkhd.type, 'tkhd', 'generated a tkhd');
+  QUnit.assert.equal(tkhd.trackId, 7, 'wrote the track id');
+  QUnit.assert.deepEqual(tkhd.flags, new Uint8Array([0, 0, 7]), 'flags should QUnit.equal 7');
+  QUnit.assert.equal(tkhd.duration,
+        expected.duration || Math.pow(2, 32) - 1,
+        'wrote duration into the track header');
+  QUnit.assert.equal(tkhd.width, expected.width || 0, 'wrote width into the track header');
+  QUnit.assert.equal(tkhd.height, expected.height || 0, 'wrote height into the track header');
+  QUnit.assert.equal(tkhd.volume, 1, 'set volume to 1');
+};
+
+validateMdia = function(mdia, expected) {
+  QUnit.assert.equal(mdia.type, 'mdia', 'generated an mdia type');
+  QUnit.assert.equal(mdia.boxes.length, 3, 'generated three track media sub boxes');
+
+  validateMdhd(mdia.boxes[0], expected);
+  validateHdlr(mdia.boxes[1], expected);
+  validateMinf(mdia.boxes[2], expected);
+};
+
+validateMdhd = function(mdhd, expected) {
+  QUnit.assert.equal(mdhd.type, 'mdhd', 'generate an mdhd type');
+  QUnit.assert.equal(mdhd.language, 'und', 'wrote undetermined language');
+  QUnit.assert.equal(mdhd.timescale, expected.timescale || 90000, 'wrote the timescale');
+  QUnit.assert.equal(mdhd.duration,
+        expected.duration || Math.pow(2, 32) - 1,
+        'wrote duration into the media header');
+};
+
+validateHdlr = function(hdlr, expected) {
+  QUnit.assert.equal(hdlr.type, 'hdlr', 'generate an hdlr type');
+  if (expected.type !== 'audio') {
+    QUnit.assert.equal(hdlr.handlerType, 'vide', 'wrote a video handler');
+    QUnit.assert.equal(hdlr.name, 'VideoHandler', 'wrote the handler name');
+  } else {
+    QUnit.assert.equal(hdlr.handlerType, 'soun', 'wrote a sound handler');
+    QUnit.assert.equal(hdlr.name, 'SoundHandler', 'wrote the sound handler name');
+  }
+};
+
+validateMinf = function(minf, expected) {
+  QUnit.assert.equal(minf.type, 'minf', 'generate an minf type');
+  QUnit.assert.equal(minf.boxes.length, 3, 'generates three minf sub boxes');
+
+  if (expected.type !== 'audio') {
+    QUnit.assert.deepEqual({
+      type: 'vmhd',
+      size: 20,
+      version: 0,
+      flags: new Uint8Array([0, 0, 1]),
+      graphicsmode: 0,
+      opcolor: new Uint16Array([0, 0, 0])
+    }, minf.boxes[0], 'generates a vhmd');
+  } else {
+    QUnit.assert.deepEqual({
+      type: 'smhd',
+      size: 16,
+      version: 0,
+      flags: new Uint8Array([0, 0, 0]),
+      balance: 0
+    }, minf.boxes[0], 'generates an smhd');
+  }
+
+  validateDinf(minf.boxes[1]);
+  validateStbl(minf.boxes[2], expected);
+};
+
+validateDinf = function(dinf) {
+  QUnit.assert.deepEqual({
+    type: 'dinf',
+    size: 36,
+    boxes: [{
+      type: 'dref',
+      size: 28,
+      version: 0,
+      flags: new Uint8Array([0, 0, 0]),
+      dataReferences: [{
+        type: 'url ',
+        size: 12,
+        version: 0,
+        flags: new Uint8Array([0, 0, 1])
+      }]
+    }]
+  }, dinf, 'generates a dinf');
+};
+
+validateStbl = function(stbl, expected) {
+  QUnit.assert.equal(stbl.type, 'stbl', 'generates an stbl type');
+  QUnit.assert.equal(stbl.boxes.length, 5, 'generated five stbl child boxes');
+
+  validateStsd(stbl.boxes[0], expected);
+  QUnit.assert.deepEqual({
+    type: 'stts',
+    size: 16,
+    version: 0,
+    flags: new Uint8Array([0, 0, 0]),
+    timeToSamples: []
+  }, stbl.boxes[1], 'generated an stts');
+  QUnit.assert.deepEqual({
+    type: 'stsc',
+    size: 16,
+    version: 0,
+    flags: new Uint8Array([0, 0, 0]),
+    sampleToChunks: []
+  }, stbl.boxes[2], 'generated an stsc');
+  QUnit.assert.deepEqual({
+    type: 'stsz',
+    version: 0,
+    size: 20,
+    flags: new Uint8Array([0, 0, 0]),
+    sampleSize: 0,
+    entries: []
+  }, stbl.boxes[3], 'generated an stsz');
+  QUnit.assert.deepEqual({
+    type: 'stco',
+    size: 16,
+    version: 0,
+    flags: new Uint8Array([0, 0, 0]),
+    chunkOffsets: []
+  }, stbl.boxes[4], 'generated and stco');
+};
+
+validateStsd = function(stsd, expected) {
+  QUnit.assert.equal(stsd.type, 'stsd', 'generated an stsd');
+  QUnit.assert.equal(stsd.sampleDescriptions.length, 1, 'generated one sample');
+  if (expected.type !== 'audio') {
+    validateVideoSample(stsd.sampleDescriptions[0]);
+  } else {
+    validateAudioSample(stsd.sampleDescriptions[0]);
+  }
+};
+
+validateVideoSample = function(sample) {
+  QUnit.assert.deepEqual(sample, {
+    type: 'avc1',
+    size: 152,
+    dataReferenceIndex: 1,
+    width: 600,
+    height: 300,
+    horizresolution: 72,
+    vertresolution: 72,
+    frameCount: 1,
+    depth: 24,
+    config: [{
+      type: 'avcC',
+      size: 30,
+      configurationVersion: 1,
+      avcProfileIndication: 3,
+      avcLevelIndication: 5,
+      profileCompatibility: 7,
+      lengthSizeMinusOne: 3,
+      sps: [new Uint8Array([
+        0, 1, 2
+      ]), new Uint8Array([
+        3, 4, 5
+      ])],
+      pps: [new Uint8Array([
+        6, 7, 8
+      ])]
+    }, {
+      type: 'btrt',
+      size: 20,
+      bufferSizeDB: 1875072,
+      maxBitrate: 3000000,
+      avgBitrate: 3000000
+    }, {
+      type: 'pasp',
+      size: 16,
+      data: new Uint8Array([0, 0, 0, 1, 0, 0, 0, 1])
+    }]
+  }, 'generated a video sample');
+};
+
+validateAudioSample = function(sample) {
+  QUnit.assert.deepEqual(sample, {
+    type: 'mp4a',
+    size: 75,
+    dataReferenceIndex: 1,
+    channelcount: 2,
+    samplesize: 16,
+    samplerate: 48000,
+    streamDescriptor: {
+      type: 'esds',
+      version: 0,
+      flags: new Uint8Array([0, 0, 0]),
+      size: 39,
+      esId: 0,
+      streamPriority: 0,
+      // these values were hard-coded based on a working audio init segment
+      decoderConfig: {
+        avgBitrate: 56000,
+        maxBitrate: 56000,
+        bufferSize: 1536,
+        objectProfileIndication: 64,
+        streamType: 5,
+        decoderConfigDescriptor: {
+          audioObjectType: 2,
+          channelConfiguration: 2,
+          length: 2,
+          samplingFrequencyIndex: 3,
+          tag: 5
+        }
+      }
+    }
+  }, 'generated an audio sample');
+};
+
+validateMvex = function(mvex, options) {
+  options = options || {
+    sampleDegradationPriority: 1
+  };
+  QUnit.assert.deepEqual({
+    type: 'mvex',
+    size: 40,
+    boxes: [{
+      type: 'trex',
+      size: 32,
+      version: 0,
+      flags: new Uint8Array([0, 0, 0]),
+      trackId: 7,
+      defaultSampleDescriptionIndex: 1,
+      defaultSampleDuration: 0,
+      defaultSampleSize: 0,
+      sampleDependsOn: 0,
+      sampleIsDependedOn: 0,
+      sampleHasRedundancy: 0,
+      samplePaddingValue: 0,
+      sampleIsDifferenceSample: true,
+      sampleDegradationPriority: options.sampleDegradationPriority
+    }]
+  }, mvex, 'writes a movie extends box');
+};
+
+QUnit.test('generates a video moov', function(assert) {
+  var
+    boxes,
+    data = mp4.generator.moov([{
+      id: 7,
+      duration: 100,
+      width: 600,
+      height: 300,
+      type: 'video',
+      profileIdc: 3,
+      levelIdc: 5,
+      profileCompatibility: 7,
+      sarRatio: [1, 1],
+      sps: [new Uint8Array([0, 1, 2]), new Uint8Array([3, 4, 5])],
+      pps: [new Uint8Array([6, 7, 8])]
+    }]);
+
+  assert.ok(data, 'box is not null');
+  boxes = mp4.tools.inspect(data);
+  assert.equal(boxes.length, 1, 'generated a single box');
+  assert.equal(boxes[0].type, 'moov', 'generated a moov type');
+  assert.equal(boxes[0].size, data.byteLength, 'generated size');
+  assert.equal(boxes[0].boxes.length, 3, 'generated three sub boxes');
+
+  validateMvhd(boxes[0].boxes[0]);
+  validateTrak(boxes[0].boxes[1], {
+    duration: 100,
+    width: 600,
+    height: 300
+  });
+  validateMvex(boxes[0].boxes[2]);
+});
+
+QUnit.test('generates an audio moov', function(assert) {
+  var
+    data = mp4.generator.moov([{
+      id: 7,
+      type: 'audio',
+      audioobjecttype: 2,
+      channelcount: 2,
+      samplerate: 48000,
+      samplingfrequencyindex: 3,
+      samplesize: 16
+    }]),
+    boxes;
+
+  assert.ok(data, 'box is not null');
+  boxes = mp4.tools.inspect(data);
+  assert.equal(boxes.length, 1, 'generated a single box');
+  assert.equal(boxes[0].type, 'moov', 'generated a moov type');
+  assert.equal(boxes[0].size, data.byteLength, 'generated size');
+  assert.equal(boxes[0].boxes.length, 3, 'generated three sub boxes');
+
+  validateMvhd(boxes[0].boxes[0]);
+  validateTrak(boxes[0].boxes[1], {
+    type: 'audio',
+    timescale: 48000
+  });
+  validateMvex(boxes[0].boxes[2], {
+    sampleDegradationPriority: 0
+  });
+});
+
+QUnit.test('generates a sound hdlr', function(assert) {
+  var boxes, hdlr,
+    data = mp4.generator.moov([{
+      duration: 100,
+      type: 'audio'
+    }]);
+
+  assert.ok(data, 'box is not null');
+
+  boxes = mp4.tools.inspect(data);
+
+  hdlr = boxes[0].boxes[1].boxes[1].boxes[1];
+  assert.equal(hdlr.type, 'hdlr', 'generate an hdlr type');
+  assert.equal(hdlr.handlerType, 'soun', 'wrote a sound handler');
+  assert.equal(hdlr.name, 'SoundHandler', 'wrote the handler name');
+});
+
+QUnit.test('generates a video hdlr', function(assert) {
+  var boxes, hdlr,
+    data = mp4.generator.moov([{
+      duration: 100,
+      width: 600,
+      height: 300,
+      type: 'video',
+      sps: [],
+      pps: []
+    }]);
+
+  assert.ok(data, 'box is not null');
+
+  boxes = mp4.tools.inspect(data);
+
+  hdlr = boxes[0].boxes[1].boxes[1].boxes[1];
+  assert.equal(hdlr.type, 'hdlr', 'generate an hdlr type');
+  assert.equal(hdlr.handlerType, 'vide', 'wrote a video handler');
+  assert.equal(hdlr.name, 'VideoHandler', 'wrote the handler name');
+});
+
+QUnit.test('generates an initialization segment', function(assert) {
+  var
+    data = mp4.generator.initSegment([{
+      id: 1,
+      width: 600,
+      height: 300,
+      type: 'video',
+      sps: [new Uint8Array([0])],
+      pps: [new Uint8Array([1])]
+    }, {
+      id: 2,
+      type: 'audio'
+    }]),
+    init, mvhd, trak1, trak2, mvex;
+
+  init = mp4.tools.inspect(data);
+  assert.equal(init.length, 2, 'generated two boxes');
+  assert.equal(init[0].type, 'ftyp', 'generated a ftyp box');
+  assert.equal(init[1].type, 'moov', 'generated a moov box');
+  assert.equal(init[1].boxes[0].duration, 0xffffffff, 'wrote a maximum duration');
+
+  mvhd = init[1].boxes[0];
+  assert.equal(mvhd.type, 'mvhd', 'wrote an mvhd');
+
+  trak1 = init[1].boxes[1];
+  assert.equal(trak1.type, 'trak', 'wrote a trak');
+  assert.equal(trak1.boxes[0].trackId, 1, 'wrote the first track id');
+  assert.equal(trak1.boxes[0].width, 600, 'wrote the first track width');
+  assert.equal(trak1.boxes[0].height, 300, 'wrote the first track height');
+  assert.equal(trak1.boxes[1].boxes[1].handlerType, 'vide', 'wrote the first track type');
+
+  trak2 = init[1].boxes[2];
+  assert.equal(trak2.type, 'trak', 'wrote a trak');
+  assert.equal(trak2.boxes[0].trackId, 2, 'wrote the second track id');
+  assert.equal(trak2.boxes[1].boxes[1].handlerType, 'soun', 'wrote the second track type');
+
+  mvex = init[1].boxes[3];
+  assert.equal(mvex.type, 'mvex', 'wrote an mvex');
+});
+
+QUnit.test('generates a minimal moof', function(assert) {
+  var
+    data = mp4.generator.moof(7, [{
+      id: 17,
+      samples: [{
+        duration: 9000,
+        size: 10,
+        flags: {
+          isLeading: 0,
+          dependsOn: 2,
+          isDependedOn: 1,
+          hasRedundancy: 0,
+          paddingValue: 0,
+          isNonSyncSample: 0,
+          degradationPriority: 14
+        },
+        compositionTimeOffset: 500
+      }, {
+        duration: 10000,
+        size: 11,
+        flags: {
+          isLeading: 0,
+          dependsOn: 1,
+          isDependedOn: 0,
+          hasRedundancy: 0,
+          paddingValue: 0,
+          isNonSyncSample: 0,
+          degradationPriority: 9
+        },
+        compositionTimeOffset: 1000
+      }]
+    }]),
+    moof = mp4.tools.inspect(data),
+    trun,
+    sdtp;
+
+  assert.equal(moof.length, 1, 'generated one box');
+  assert.equal(moof[0].type, 'moof', 'generated a moof box');
+  assert.equal(moof[0].boxes.length, 2, 'generated two child boxes');
+  assert.equal(moof[0].boxes[0].type, 'mfhd', 'generated an mfhd box');
+  assert.equal(moof[0].boxes[0].sequenceNumber, 7, 'included the sequence_number');
+  assert.equal(moof[0].boxes[1].type, 'traf', 'generated a traf box');
+  assert.equal(moof[0].boxes[1].boxes.length, 4, 'generated track fragment info');
+  assert.equal(moof[0].boxes[1].boxes[0].type, 'tfhd', 'generated a tfhd box');
+  assert.equal(moof[0].boxes[1].boxes[0].trackId, 17, 'wrote the first track id');
+  assert.equal(moof[0].boxes[1].boxes[0].baseDataOffset, undefined, 'did not set a base data offset');
+
+  assert.equal(moof[0].boxes[1].boxes[1].type, 'tfdt', 'generated a tfdt box');
+  assert.ok(moof[0].boxes[1].boxes[1].baseMediaDecodeTime >= 0,
+     'media decode time is non-negative');
+
+  trun = moof[0].boxes[1].boxes[2];
+  assert.equal(trun.type, 'trun', 'generated a trun box');
+  assert.equal(typeof trun.dataOffset, 'number', 'has a data offset');
+  assert.ok(trun.dataOffset >= 0, 'has a non-negative data offset');
+  assert.equal(trun.dataOffset, moof[0].size + 8, 'sets the data offset past the mdat header');
+  assert.equal(trun.samples.length, 2, 'wrote two samples');
+
+  assert.equal(trun.samples[0].duration, 9000, 'wrote a sample duration');
+  assert.equal(trun.samples[0].size, 10, 'wrote a sample size');
+  assert.deepEqual(trun.samples[0].flags, {
+    isLeading: 0,
+    dependsOn: 2,
+    isDependedOn: 1,
+    hasRedundancy: 0,
+    paddingValue: 0,
+    isNonSyncSample: 0,
+    degradationPriority: 14
+  }, 'wrote the sample flags');
+  assert.equal(trun.samples[0].compositionTimeOffset, 500, 'wrote the composition time offset');
+
+  assert.equal(trun.samples[1].duration, 10000, 'wrote a sample duration');
+  assert.equal(trun.samples[1].size, 11, 'wrote a sample size');
+  assert.deepEqual(trun.samples[1].flags, {
+    isLeading: 0,
+    dependsOn: 1,
+    isDependedOn: 0,
+    hasRedundancy: 0,
+    paddingValue: 0,
+    isNonSyncSample: 0,
+    degradationPriority: 9
+  }, 'wrote the sample flags');
+  assert.equal(trun.samples[1].compositionTimeOffset, 1000, 'wrote the composition time offset');
+
+  sdtp = moof[0].boxes[1].boxes[3];
+  assert.equal(sdtp.type, 'sdtp', 'generated an sdtp box');
+  assert.equal(sdtp.samples.length, 2, 'wrote two samples');
+  assert.deepEqual(sdtp.samples[0], {
+      dependsOn: 2,
+      isDependedOn: 1,
+      hasRedundancy: 0
+  }, 'wrote the sample data table');
+  assert.deepEqual(sdtp.samples[1], {
+    dependsOn: 1,
+    isDependedOn: 0,
+    hasRedundancy: 0
+  }, 'wrote the sample data table');
+});
+
+QUnit.test('generates a moof for audio', function(assert) {
+  var
+    data = mp4.generator.moof(7, [{
+      id: 17,
+      type: 'audio',
+      samples: [{
+        duration: 9000,
+        size: 10
+      }, {
+        duration: 10000,
+        size: 11
+      }]
+    }]),
+    moof = mp4.tools.inspect(data),
+    trun;
+
+  assert.deepEqual(moof[0].boxes[1].boxes.length, 3, 'generated three traf children');
+  trun = moof[0].boxes[1].boxes[2];
+  assert.ok(trun, 'generated a trun');
+  assert.equal(trun.dataOffset, data.byteLength + 8, 'calculated the data offset');
+  assert.deepEqual(trun.samples, [{
+    duration: 9000,
+    size: 10
+  }, {
+    duration: 10000,
+    size: 11
+  }], 'wrote simple audio samples');
+});
+
+QUnit.test('can generate a traf without samples', function(assert) {
+  var
+    data = mp4.generator.moof(8, [{
+      trackId: 13
+    }]),
+    moof = mp4.tools.inspect(data);
+
+  assert.equal(moof[0].boxes[1].boxes[2].samples.length, 0, 'generated no samples');
+});
+
+QUnit.test('generates an mdat', function(assert) {
+  var
+    data = mp4.generator.mdat(new Uint8Array([1, 2, 3, 4])),
+    mdat = mp4.tools.inspect(data);
+
+  assert.equal(mdat.length, 1, 'generated one box');
+  assert.equal(mdat[0].type, 'mdat', 'generated an mdat box');
+  assert.deepEqual(mdat[0].byteLength, 4, 'encapsulated the data');
+});