test-dist-es6-5/IsoBmff/index.js

A media file format generator/parser that exposes a React-like API.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _get2 = require('babel-runtime/helpers/get');

var _get3 = _interopRequireDefault(_get2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _MediaFormat = require('../core/MediaFormat');

var _Box = require('./Box/Box');

var _Box2 = _interopRequireDefault(_Box);

var _UnknownBox = require('./Box/UnknownBox');

var _UnknownBox2 = _interopRequireDefault(_UnknownBox);

var _Stream = require('../core/Stream');

var _Visitor = require('../core/Visitor');

var _BoxVisitor = require('./BoxVisitor');

var _Error = require('../core/Error');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var clazz = {
  'file': require('./Box/File').default,
  'ftyp': require('./Box/FileTypeBox').default,
  'moov': require('./Box/MovieBox').default,
  'mvhd': require('./Box/MovieHeaderBox').default,
  'trak': require('./Box/TrackBox').default,
  'tkhd': require('./Box/TrackHeaderBox').default,
  'mdia': require('./Box/MediaBox').default,
  'mdhd': require('./Box/MediaHeaderBox').default,
  'hdlr': require('./Box/HandlerReferenceBox').default,
  'minf': require('./Box/MediaInformationBox').default,
  'vmhd': require('./Box/VideoMediaHeaderBox').default,
  'smhd': require('./Box/SoundMediaHeaderBox').default,
  'hmhd': require('./Box/HintMediaHeaderBox').default,
  'nmhd': require('./Box/NullMediaHeaderBox').default,
  'dinf': require('./Box/DataInformationBox').default,
  'dref': require('./Box/DataReferenceBox').default,
  'url ': require('./Box/DataEntryUrlBox').default,
  'urn ': require('./Box/DataEntryUrnBox').default,
  'stbl': require('./Box/SampleTableBox').default,
  'stsd': require('./Box/SampleDescriptionBox').default,
  'avc1': require('./Box/AVCSampleEntry').default,
  'avcC': require('./Box/AVCConfigurationBox').default,
  'stts': require('./Box/TimeToSampleBox').default,
  'stsz': require('./Box/SampleSizeBox').default,
  'stz2': require('./Box/CompactSampleSizeBox').default,
  'stsc': require('./Box/SampleToChunkBox').default,
  'stco': require('./Box/ChunkOffsetBox').default,
  'mp4a': require('./Box/MP4AudioSampleEntry').default,
  'esds': require('./Box/ESDBox').default,
  'mdat': require('./Box/MediaDataBox').default,
  'btrt': require('./Box/MPEG4BitRateBox').default,
  'stss': require('./Box/SyncSampleBox').default,
  'mvex': require('./Box/MovieExtendsBox').default,
  'mehd': require('./Box/MovieExtendsHeaderBox').default,
  'trex': require('./Box/TrackExtendsBox').default,
  'moof': require('./Box/MovieFragmentBox').default,
  'mfhd': require('./Box/MovieFragmentHeaderBox').default,
  'traf': require('./Box/TrackFragmentBox').default,
  'tfhd': require('./Box/TrackFragmentHeaderBox').default,
  'trun': require('./Box/TrackRunBox').default,
  'tfdt': require('./Box/TrackFragmentBaseMediaDecodeTimeBox').default
};

function validateChild(context, child) {
  var childSpec = child.type.spec;
  var childName = child.type.COMPACT_NAME;
  var checkList = context.mandatoryCheckList;
  var quantityTable = context.quantityTable;

  var container = void 0,
      quantity = void 0;

  // Container check.
  if (childSpec.container) {
    if (childSpec.container instanceof Array) {
      container = childSpec.container;
    } else {
      container = [childSpec.container];
    }
    if (container.indexOf(context.container) === -1) {
      return [false, '"' + childName + '" cannot be a child of "' + context.container + '"'];
    }
  }

  // Mandatory check.
  checkList[childName] = true;

  // Quantity check.
  if ((quantity = childSpec.quantity) !== _Box2.default.QUANTITY_ANY_NUMBER) {
    // Increment
    if (quantityTable[childName] === void 0) {
      quantityTable[childName] = 1;
    } else {
      quantityTable[childName]++;
    }
    // Validate
    if (quantity === _Box2.default.QUANTITY_EXACTLY_ONE) {
      if (quantityTable[childName] !== 1) {
        return [false, 'Quantity of ' + childName + ' should be exactly one.'];
      }
    } else if (quantity === _Box2.default.QUANTITY_ZERO_OR_ONE) {
      if (quantityTable[childName] > 1) {
        return [false, 'Quantity of ' + childName + ' should be zero or one.'];
      }
    }
  }
  return [true, null];
}

function createElement(type) {
  var componentClass = void 0,
      element = void 0,
      context = {},
      spec = void 0,
      result = void 0,
      errorMessage = void 0,
      checkList = void 0;

  // Validate type.
  if (typeof type === 'string') {
    componentClass = clazz[type];
    if (!componentClass) {
      console.error('IsoBmff.createElement: invalid type: "' + type + '"');
      return null;
    }
    type = componentClass;
  } else if (!type || !(type instanceof _Box2.default)) {
    console.error('IsoBmff.createElement: "type" should be a subclass of the Box.');
    return null;
  } else {
    componentClass = type;
  }

  // Create element.

  for (var _len = arguments.length, otherParams = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    otherParams[_key - 1] = arguments[_key];
  }

  if (!(element = _MediaFormat.createElement.apply(undefined, [type].concat(otherParams)))) {
    return null;
  }

  // Validate children.
  spec = componentClass.spec;
  context = {
    container: componentClass.COMPACT_NAME,
    mandatoryCheckList: {},
    quantityTable: {}
  };

  if (!element.props.children.every(function (child) {
    var _validateChild = validateChild(context, child);

    var _validateChild2 = (0, _slicedToArray3.default)(_validateChild, 2);

    result = _validateChild2[0];
    errorMessage = _validateChild2[1];

    return result;
  })) {
    console.error('IsoBmff.createElement: Breaking the composition rule: ' + errorMessage);
    return null;
  }

  checkList = context.mandatoryCheckList;

  spec.mandatoryBoxList.forEach(function (boxType) {
    if (boxType instanceof Array) {
      if (boxType.some(function (box) {
        return checkList[box];
      })) {
        return;
      }
      boxType = boxType.join('", or "');
    } else {
      if (checkList[boxType]) {
        return;
      }
    }
    console.error('IsoBmff.createElement: Breaking the composition rule: "' + boxType + '" is required as a child of "' + context.container + '"');
    element = null;
  });

  return element;
}

function parse(buffer, offset, visitor) {
  var readBytesNum = void 0;
  var props = void 0;
  var base = offset;

  // Read the Box params as we don't know the type.

  var _Box$parse = _Box2.default.parse(buffer, offset);

  var _Box$parse2 = (0, _slicedToArray3.default)(_Box$parse, 2);

  readBytesNum = _Box$parse2[0];
  props = _Box$parse2[1];


  var boxSize = props.size || buffer.length - offset;
  var boxEnd = offset + boxSize;
  var boxType = props.type === 'uuid' ? props.extendedType : props.type;

  //console.log(`parse enter.: type=${boxType} size=${boxSize} offset=${offset}`);

  if (boxType.length < 4) {
    console.error('IsoBmff.createElementFromBuffer: Invalid type - "' + boxType + '"');
    visitor.offset += readBytesNum;
    return boxSize;
  }

  var boxClass = clazz[boxType];

  if (!boxClass) {
    console.error('IsoBmff.createElementFromBuffer: Unsupported type - "' + boxType + '"');

    var _UnknownBox$parse = _UnknownBox2.default.parse(buffer, offset, boxType);

    var _UnknownBox$parse2 = (0, _slicedToArray3.default)(_UnknownBox$parse, 2);

    readBytesNum = _UnknownBox$parse2[0];
    props = _UnknownBox$parse2[1];

    boxClass = _UnknownBox2.default;
  } else {
    var _boxClass$parse = boxClass.parse(buffer, offset);

    var _boxClass$parse2 = (0, _slicedToArray3.default)(_boxClass$parse, 2);

    readBytesNum = _boxClass$parse2[0];
    props = _boxClass$parse2[1];
  }
  base += readBytesNum;

  visitor.offset = base;
  visitor.enter(boxClass, props);

  while (base < boxEnd) {
    readBytesNum = parse(buffer, base, visitor);
    base += readBytesNum;
  }
  visitor.exit();
  visitor.offset = base;

  //console.log(`parse exit.: type=${boxType} readBytesNum=${Math.min(base - offset, boxSize)}`);
  return Math.min(base - offset, boxSize);
}

function createElementFromBuffer(buffer) {
  var offset = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];

  var base = offset;

  if (buffer instanceof ArrayBuffer) {
    buffer = new Uint8Array(buffer);
  }
  var endOfBuffer = base + buffer.length;

  var visitor = new _Visitor.ElementVisitor();

  try {
    while (base < endOfBuffer) {
      var readBytesNum = parse(buffer, base, visitor);
      base += readBytesNum;
    }
  } catch (err) {
    if (err.message !== _Error.BufferReadError.ERROR_MESSAGE) {
      console.error('IsoBmff.transform: An error occurred in parsing the buffer: ' + err.stack);
    }
    return null;
  }
  //console.log(`IsoBmff.createElementFromBuffer: Done. ${base - offset} bytes read.`);
  if (visitor.results.length === 0) {
    return null;
  } else if (visitor.results.length === 1) {
    return visitor.results[0];
  }
  return _MediaFormat.createElement.apply(undefined, [clazz.file, null].concat((0, _toConsumableArray3.default)(visitor.results)));
}

function transform(visitor) {
  var Kontainer = require('..').default; // Ugly..
  var vtor = void 0;

  if (visitor instanceof _Visitor.Visitor) {
    vtor = visitor;
  } else {
    // Received a filter function

    var TransformVisitor = function (_ElementVisitor) {
      (0, _inherits3.default)(TransformVisitor, _ElementVisitor);

      function TransformVisitor() {
        (0, _classCallCheck3.default)(this, TransformVisitor);
        return (0, _possibleConstructorReturn3.default)(this, (0, _getPrototypeOf2.default)(TransformVisitor).apply(this, arguments));
      }

      (0, _createClass3.default)(TransformVisitor, [{
        key: 'visit',
        value: function visit(type, props, children) {
          visitor(type.COMPACT_NAME, props, children);
          return (0, _get3.default)((0, _getPrototypeOf2.default)(TransformVisitor.prototype), 'visit', this).call(this, type, props, children);
        }
      }]);
      return TransformVisitor;
    }(_Visitor.ElementVisitor);

    vtor = new TransformVisitor();
  }

  return new _Stream.TransformStream(function (buffer, offset, done) {
    var base = vtor.offset;
    var buf = buffer.getData();

    if (buf instanceof ArrayBuffer) {
      buf = new Uint8Array(buf);
    }
    var endOfBuffer = buf.length;
    try {
      while (base < endOfBuffer) {
        var readBytesNum = parse(buf, base, vtor);
        base += readBytesNum;
      }
    } catch (err) {
      if (err.message !== _Error.BufferReadError.ERROR_MESSAGE) {
        console.error('IsoBmff.transform: An error occurred in parsing the buffer: ' + err.stack);
      }
      done(null, null);
      return;
    }

    while (vtor.stack.length) {
      vtor.exit();
    }
    done(null, Kontainer.renderToBuffer(_MediaFormat.createElement.apply(undefined, [clazz.file, null].concat((0, _toConsumableArray3.default)(vtor.results)))));
  });
}

exports.default = {
  createElement: createElement,
  createElementFromBuffer: createElementFromBuffer,
  transform: transform,
  ElementVisitor: _Visitor.ElementVisitor,
  IsoBmffDumpVisitor: _BoxVisitor.IsoBmffDumpVisitor
};