jmuxer.min.js

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	typeof define === 'function' && define.amd ? define(factory) :
	(global.JMuxer = factory());
}(this, (function () { 'use strict';

var logger = void 0;
var errorLogger = void 0;

function setLogger() {
    /*eslint-disable */
    logger = console.log;
    errorLogger = console.error;
    /*eslint-enable */
}



function log(message) {
    if (logger) {
        for (var _len = arguments.length, optionalParams = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            optionalParams[_key - 1] = arguments[_key];
        }

        logger.apply(undefined, [message].concat(optionalParams));
    }
}
function error(message) {
    if (errorLogger) {
        for (var _len2 = arguments.length, optionalParams = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
            optionalParams[_key2 - 1] = arguments[_key2];
        }

        errorLogger.apply(undefined, [message].concat(optionalParams));
    }
}

var asyncGenerator = function () {
  function AwaitValue(value) {
    this.value = value;
  }

  function AsyncGenerator(gen) {
    var front, back;

    function send(key, arg) {
      return new Promise(function (resolve, reject) {
        var request = {
          key: key,
          arg: arg,
          resolve: resolve,
          reject: reject,
          next: null
        };

        if (back) {
          back = back.next = request;
        } else {
          front = back = request;
          resume(key, arg);
        }
      });
    }

    function resume(key, arg) {
      try {
        var result = gen[key](arg);
        var value = result.value;

        if (value instanceof AwaitValue) {
          Promise.resolve(value.value).then(function (arg) {
            resume("next", arg);
          }, function (arg) {
            resume("throw", arg);
          });
        } else {
          settle(result.done ? "return" : "normal", result.value);
        }
      } catch (err) {
        settle("throw", err);
      }
    }

    function settle(type, value) {
      switch (type) {
        case "return":
          front.resolve({
            value: value,
            done: true
          });
          break;

        case "throw":
          front.reject(value);
          break;

        default:
          front.resolve({
            value: value,
            done: false
          });
          break;
      }

      front = front.next;

      if (front) {
        resume(front.key, front.arg);
      } else {
        back = null;
      }
    }

    this._invoke = send;

    if (typeof gen.return !== "function") {
      this.return = undefined;
    }
  }

  if (typeof Symbol === "function" && Symbol.asyncIterator) {
    AsyncGenerator.prototype[Symbol.asyncIterator] = function () {
      return this;
    };
  }

  AsyncGenerator.prototype.next = function (arg) {
    return this._invoke("next", arg);
  };

  AsyncGenerator.prototype.throw = function (arg) {
    return this._invoke("throw", arg);
  };

  AsyncGenerator.prototype.return = function (arg) {
    return this._invoke("return", arg);
  };

  return {
    wrap: function (fn) {
      return function () {
        return new AsyncGenerator(fn.apply(this, arguments));
      };
    },
    await: function (value) {
      return new AwaitValue(value);
    }
  };
}();





var classCallCheck = function (instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
};

var createClass = function () {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();





var defineProperty = function (obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
};



var inherits = function (subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
};











var possibleConstructorReturn = function (self, call) {
  if (!self) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return call && (typeof call === "object" || typeof call === "function") ? call : self;
};

var NALU = function () {
    createClass(NALU, null, [{
        key: 'type',
        value: function type(nalu) {
            if (nalu.ntype in NALU.TYPES) {
                return NALU.TYPES[nalu.ntype];
            } else {
                return 'UNKNOWN';
            }
        }
    }, {
        key: 'NDR',
        get: function get$$1() {
            return 1;
        }
    }, {
        key: 'IDR',
        get: function get$$1() {
            return 5;
        }
    }, {
        key: 'SEI',
        get: function get$$1() {
            return 6;
        }
    }, {
        key: 'SPS',
        get: function get$$1() {
            return 7;
        }
    }, {
        key: 'PPS',
        get: function get$$1() {
            return 8;
        }
    }, {
        key: 'AUD',
        get: function get$$1() {
            return 9;
        }
    }, {
        key: 'TYPES',
        get: function get$$1() {
            var _ref;

            return _ref = {}, babelHelpers.defineProperty(_ref, NALU.IDR, 'IDR'), babelHelpers.defineProperty(_ref, NALU.SEI, 'SEI'), babelHelpers.defineProperty(_ref, NALU.SPS, 'SPS'), babelHelpers.defineProperty(_ref, NALU.PPS, 'PPS'), babelHelpers.defineProperty(_ref, NALU.NDR, 'NDR'), babelHelpers.defineProperty(_ref, NALU.AUD, 'AUD'), _ref;
        }
    }]);

    function NALU(data) {
        classCallCheck(this, NALU);

        this.payload = data;
        this.nri = (this.payload[0] & 0x60) >> 5;
        this.ntype = this.payload[0] & 0x1f;
    }

    createClass(NALU, [{
        key: 'toString',
        value: function toString() {
            return NALU.type(this) + ': NRI: ' + this.getNri();
        }
    }, {
        key: 'getNri',
        value: function getNri() {
            return this.nri >> 6;
        }
    }, {
        key: 'type',
        value: function type() {
            return this.ntype;
        }
    }, {
        key: 'isKeyframe',
        value: function isKeyframe() {
            return this.ntype == NALU.IDR;
        }
    }, {
        key: 'getSize',
        value: function getSize() {
            return 4 + this.payload.byteLength;
        }
    }, {
        key: 'getData',
        value: function getData() {
            var result = new Uint8Array(this.getSize());
            var view = new DataView(result.buffer);
            view.setUint32(0, this.getSize() - 4);

            result.set(this.payload, 4);
            return result;
        }
    }]);
    return NALU;
}();

/**
 * Parser for exponential Golomb codes, a variable-bitwidth number encoding scheme used by h264.
*/

var ExpGolomb = function () {
    function ExpGolomb(data) {
        classCallCheck(this, ExpGolomb);

        this.data = data;
        this.index = 0;
        this.bitLength = data.byteLength * 8;
    }

    createClass(ExpGolomb, [{
        key: "skipBits",
        value: function skipBits(size) {
            // console.log(`  skip bits: size=${size}, ${this.index}.`);
            if (this.bitsAvailable < size) {
                //throw new Error('no bytes available');
                return false;
            }
            this.index += size;
        }
    }, {
        key: "readBits",
        value: function readBits(size) {
            var moveIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

            // console.log(`  read bits: size=${size}, ${this.index}.`);
            var result = this.getBits(size, this.index, moveIndex);
            // console.log(`    read bits: result=${result}`);
            return result;
        }
    }, {
        key: "getBits",
        value: function getBits(size, offsetBits) {
            var moveIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;

            if (this.bitsAvailable < size) {
                //throw new Error('no bytes available');
                return 0;
            }
            var offset = offsetBits % 8;
            var byte = this.data[offsetBits / 8 | 0] & 0xff >>> offset;
            var bits = 8 - offset;
            if (bits >= size) {
                if (moveIndex) {
                    this.index += size;
                }
                return byte >> bits - size;
            } else {
                if (moveIndex) {
                    this.index += bits;
                }
                var nextSize = size - bits;
                return byte << nextSize | this.getBits(nextSize, offsetBits + bits, moveIndex);
            }
        }
    }, {
        key: "skipLZ",
        value: function skipLZ() {
            var leadingZeroCount = void 0;
            for (leadingZeroCount = 0; leadingZeroCount < this.bitLength - this.index; ++leadingZeroCount) {
                if (this.getBits(1, this.index + leadingZeroCount, false) !== 0) {
                    // console.log(`  skip LZ  : size=${leadingZeroCount}, ${this.index}.`);
                    this.index += leadingZeroCount;
                    return leadingZeroCount;
                }
            }
            return leadingZeroCount;
        }
    }, {
        key: "skipUEG",
        value: function skipUEG() {
            this.skipBits(1 + this.skipLZ());
        }
    }, {
        key: "skipEG",
        value: function skipEG() {
            this.skipBits(1 + this.skipLZ());
        }
    }, {
        key: "readUEG",
        value: function readUEG() {
            var prefix = this.skipLZ();
            return this.readBits(prefix + 1) - 1;
        }
    }, {
        key: "readEG",
        value: function readEG() {
            var value = this.readUEG();
            if (0x01 & value) {
                // the number is odd if the low order bit is set
                return 1 + value >>> 1; // add 1 to make it even, and divide by 2
            } else {
                return -1 * (value >>> 1); // divide by two then make it negative
            }
        }
    }, {
        key: "readBoolean",
        value: function readBoolean() {
            return this.readBits(1) === 1;
        }
    }, {
        key: "readUByte",
        value: function readUByte() {
            var numberOfBytes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;

            return this.readBits(numberOfBytes * 8);
        }
    }, {
        key: "readUShort",
        value: function readUShort() {
            return this.readBits(16);
        }
    }, {
        key: "readUInt",
        value: function readUInt() {
            return this.readBits(32);
        }
    }, {
        key: "bitsAvailable",
        get: function get$$1() {
            return this.bitLength - this.index;
        }
    }]);
    return ExpGolomb;
}();

var H264Parser = function () {
    createClass(H264Parser, null, [{
        key: 'extractNALu',
        value: function extractNALu(buffer) {
            var i = 0,
                length = buffer.byteLength,
                value = void 0,
                state = 0,
                result = [],
                lastIndex = void 0;

            while (i < length) {
                value = buffer[i++];
                // finding 3 or 4-byte start codes (00 00 01 OR 00 00 00 01)
                switch (state) {
                    case 0:
                        if (value === 0) {
                            state = 1;
                        }
                        break;
                    case 1:
                        if (value === 0) {
                            state = 2;
                        } else {
                            state = 0;
                        }
                        break;
                    case 2:
                    case 3:
                        if (value === 0) {
                            state = 3;
                        } else if (value === 1 && i < length) {
                            if (lastIndex) {
                                result.push(buffer.subarray(lastIndex, i - state - 1));
                            }
                            lastIndex = i;
                            state = 0;
                        } else {
                            state = 0;
                        }
                        break;
                    default:
                        break;
                }
            }

            if (lastIndex) {
                result.push(buffer.subarray(lastIndex, length));
            }
            return result;
        }

        /**
         * Advance the ExpGolomb decoder past a scaling list. The scaling
         * list is optionally transmitted as part of a sequence parameter
         * set and is not relevant to transmuxing.
         * @param decoder {ExpGolomb} exp golomb decoder
         * @param count {number} the number of entries in this scaling list
         * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
         */

    }, {
        key: 'skipScalingList',
        value: function skipScalingList(decoder, count) {
            var lastScale = 8,
                nextScale = 8,
                deltaScale = void 0;
            for (var j = 0; j < count; j++) {
                if (nextScale !== 0) {
                    deltaScale = decoder.readEG();
                    nextScale = (lastScale + deltaScale + 256) % 256;
                }
                lastScale = nextScale === 0 ? lastScale : nextScale;
            }
        }

        /**
         * Read a sequence parameter set and return some interesting video
         * properties. A sequence parameter set is the H264 metadata that
         * describes the properties of upcoming video frames.
         * @param data {Uint8Array} the bytes of a sequence parameter set
         * @return {object} an object with configuration parsed from the
         * sequence parameter set, including the dimensions of the
         * associated video frames.
         */

    }, {
        key: 'readSPS',
        value: function readSPS(data) {
            var decoder = new ExpGolomb(data);
            var frameCropLeftOffset = 0,
                frameCropRightOffset = 0,
                frameCropTopOffset = 0,
                frameCropBottomOffset = 0,
                sarScale = 1,
                profileIdc = void 0,
                profileCompat = void 0,
                levelIdc = void 0,
                numRefFramesInPicOrderCntCycle = void 0,
                picWidthInMbsMinus1 = void 0,
                picHeightInMapUnitsMinus1 = void 0,
                frameMbsOnlyFlag = void 0,
                scalingListCount = void 0;
            decoder.readUByte();
            profileIdc = decoder.readUByte(); // profile_idc
            profileCompat = decoder.readBits(5); // constraint_set[0-4]_flag, u(5)
            decoder.skipBits(3); // reserved_zero_3bits u(3),
            levelIdc = decoder.readUByte(); // level_idc u(8)
            decoder.skipUEG(); // seq_parameter_set_id
            // some profiles have more optional data we don't need
            if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
                var chromaFormatIdc = decoder.readUEG();
                if (chromaFormatIdc === 3) {
                    decoder.skipBits(1); // separate_colour_plane_flag
                }
                decoder.skipUEG(); // bit_depth_luma_minus8
                decoder.skipUEG(); // bit_depth_chroma_minus8
                decoder.skipBits(1); // qpprime_y_zero_transform_bypass_flag
                if (decoder.readBoolean()) {
                    // seq_scaling_matrix_present_flag
                    scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
                    for (var i = 0; i < scalingListCount; ++i) {
                        if (decoder.readBoolean()) {
                            // seq_scaling_list_present_flag[ i ]
                            if (i < 6) {
                                H264Parser.skipScalingList(decoder, 16);
                            } else {
                                H264Parser.skipScalingList(decoder, 64);
                            }
                        }
                    }
                }
            }
            decoder.skipUEG(); // log2_max_frame_num_minus4
            var picOrderCntType = decoder.readUEG();
            if (picOrderCntType === 0) {
                decoder.readUEG(); // log2_max_pic_order_cnt_lsb_minus4
            } else if (picOrderCntType === 1) {
                decoder.skipBits(1); // delta_pic_order_always_zero_flag
                decoder.skipEG(); // offset_for_non_ref_pic
                decoder.skipEG(); // offset_for_top_to_bottom_field
                numRefFramesInPicOrderCntCycle = decoder.readUEG();
                for (var _i = 0; _i < numRefFramesInPicOrderCntCycle; ++_i) {
                    decoder.skipEG(); // offset_for_ref_frame[ i ]
                }
            }
            decoder.skipUEG(); // max_num_ref_frames
            decoder.skipBits(1); // gaps_in_frame_num_value_allowed_flag
            picWidthInMbsMinus1 = decoder.readUEG();
            picHeightInMapUnitsMinus1 = decoder.readUEG();
            frameMbsOnlyFlag = decoder.readBits(1);
            if (frameMbsOnlyFlag === 0) {
                decoder.skipBits(1); // mb_adaptive_frame_field_flag
            }
            decoder.skipBits(1); // direct_8x8_inference_flag
            if (decoder.readBoolean()) {
                // frame_cropping_flag
                frameCropLeftOffset = decoder.readUEG();
                frameCropRightOffset = decoder.readUEG();
                frameCropTopOffset = decoder.readUEG();
                frameCropBottomOffset = decoder.readUEG();
            }
            if (decoder.readBoolean()) {
                // vui_parameters_present_flag
                if (decoder.readBoolean()) {
                    // aspect_ratio_info_present_flag
                    var sarRatio = void 0;
                    var aspectRatioIdc = decoder.readUByte();
                    switch (aspectRatioIdc) {
                        case 1:
                            sarRatio = [1, 1];break;
                        case 2:
                            sarRatio = [12, 11];break;
                        case 3:
                            sarRatio = [10, 11];break;
                        case 4:
                            sarRatio = [16, 11];break;
                        case 5:
                            sarRatio = [40, 33];break;
                        case 6:
                            sarRatio = [24, 11];break;
                        case 7:
                            sarRatio = [20, 11];break;
                        case 8:
                            sarRatio = [32, 11];break;
                        case 9:
                            sarRatio = [80, 33];break;
                        case 10:
                            sarRatio = [18, 11];break;
                        case 11:
                            sarRatio = [15, 11];break;
                        case 12:
                            sarRatio = [64, 33];break;
                        case 13:
                            sarRatio = [160, 99];break;
                        case 14:
                            sarRatio = [4, 3];break;
                        case 15:
                            sarRatio = [3, 2];break;
                        case 16:
                            sarRatio = [2, 1];break;
                        case 255:
                            {
                                sarRatio = [decoder.readUByte() << 8 | decoder.readUByte(), decoder.readUByte() << 8 | decoder.readUByte()];
                                break;
                            }
                    }
                    if (sarRatio) {
                        sarScale = sarRatio[0] / sarRatio[1];
                    }
                }
                if (decoder.readBoolean()) {
                    decoder.skipBits(1);
                }

                if (decoder.readBoolean()) {
                    decoder.skipBits(4);
                    if (decoder.readBoolean()) {
                        decoder.skipBits(24);
                    }
                }
                if (decoder.readBoolean()) {
                    decoder.skipUEG();
                    decoder.skipUEG();
                }
                if (decoder.readBoolean()) {
                    var unitsInTick = decoder.readUInt();
                    var timeScale = decoder.readUInt();
                    var fixedFrameRate = decoder.readBoolean();
                    
                }
            }
            return {
                width: Math.ceil(((picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2) * sarScale),
                height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset)
            };
        }
    }]);

    function H264Parser(remuxer) {
        classCallCheck(this, H264Parser);

        this.remuxer = remuxer;
        this.track = remuxer.mp4track;
    }

    createClass(H264Parser, [{
        key: 'parseSPS',
        value: function parseSPS(sps) {
            var config = H264Parser.readSPS(new Uint8Array(sps));

            this.track.width = config.width;
            this.track.height = config.height;
            this.track.sps = [new Uint8Array(sps)];
            this.track.codec = 'avc1.';

            var codecarray = new DataView(sps.buffer, sps.byteOffset + 1, 4);
            for (var i = 0; i < 3; ++i) {
                var h = codecarray.getUint8(i).toString(16);
                if (h.length < 2) {
                    h = '0' + h;
                }
                this.track.codec += h;
            }
        }
    }, {
        key: 'parsePPS',
        value: function parsePPS(pps) {
            this.track.pps = [new Uint8Array(pps)];
        }
    }, {
        key: 'parseNAL',
        value: function parseNAL(unit) {
            if (!unit) return false;

            var push = false;
            switch (unit.type()) {
                case NALU.NDR:
                    push = true;
                    break;
                case NALU.IDR:
                    push = true;
                    break;
                case NALU.PPS:
                    if (!this.track.pps) {
                        this.parsePPS(unit.getData().subarray(4));
                        if (!this.remuxer.readyToDecode && this.track.pps && this.track.sps) {
                            this.remuxer.readyToDecode = true;
                        }
                    }
                    push = true;
                    break;
                case NALU.SPS:
                    if (!this.track.sps) {
                        this.parseSPS(unit.getData().subarray(4));
                        if (!this.remuxer.readyToDecode && this.track.pps && this.track.sps) {
                            this.remuxer.readyToDecode = true;
                        }
                    }
                    push = true;
                    break;
                case NALU.AUD:
                    log('AUD - ignoing and disable HD mode for live channel');
                    if (this.remuxer.isHDAvail) {
                        this.remuxer.isHDAvail = false;
                    }
                    break;
                case NALU.SEI:
                    log('SEI - ignoing');
                    break;
                default:
            }
            return push;
        }
    }]);
    return H264Parser;
}();

var aacHeader = void 0;
var AACParser = function () {
    createClass(AACParser, null, [{
        key: 'getHeaderLength',
        value: function getHeaderLength(data) {
            return data[1] & 0x01 ? 7 : 9; // without CRC 7 and with CRC 9 Refs: https://wiki.multimedia.cx/index.php?title=ADTS
        }
    }, {
        key: 'getFrameLength',
        value: function getFrameLength(data) {
            return (data[3] & 0x03) << 11 | data[4] << 3 | (data[5] & 0xE0) >>> 5; // 13 bits length ref: https://wiki.multimedia.cx/index.php?title=ADTS
        }
    }, {
        key: 'isAACPattern',
        value: function isAACPattern(data) {
            return data[0] === 0xff && (data[1] & 0xf0) === 0xf0 && (data[1] & 0x06) === 0x00;
        }
    }, {
        key: 'extractAAC',
        value: function extractAAC(buffer) {
            var i = 0,
                length = buffer.byteLength,
                result = [],
                headerLength = void 0,
                frameLength = void 0;

            if (!AACParser.isAACPattern(buffer)) {
                error('Invalid ADTS audio format');
                return result;
            }
            headerLength = AACParser.getHeaderLength(buffer);
            if (!aacHeader) {
                aacHeader = buffer.subarray(0, headerLength);
            }

            while (i < length) {
                frameLength = AACParser.getFrameLength(buffer);
                result.push(buffer.subarray(headerLength, frameLength));
                buffer = buffer.slice(frameLength);
                i += frameLength;
            }
            return result;
        }
    }, {
        key: 'samplingRateMap',
        get: function get$$1() {
            return [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
        }
    }, {
        key: 'getAACHeaderData',
        get: function get$$1() {
            return aacHeader;
        }
    }]);

    function AACParser(remuxer) {
        classCallCheck(this, AACParser);

        this.remuxer = remuxer;
        this.track = remuxer.mp4track;
    }

    createClass(AACParser, [{
        key: 'setAACConfig',
        value: function setAACConfig() {
            var objectType = void 0,
                sampleIndex = void 0,
                channelCount = void 0,
                config = new Uint8Array(2),
                headerData = AACParser.getAACHeaderData;

            if (!headerData) return;

            objectType = ((headerData[2] & 0xC0) >>> 6) + 1;
            sampleIndex = (headerData[2] & 0x3C) >>> 2;
            channelCount = (headerData[2] & 0x01) << 2;
            channelCount |= (headerData[3] & 0xC0) >>> 6;

            /* refer to http://wiki.multimedia.cx/index.php?title=MPEG-4_Audio#Audio_Specific_Config */
            config[0] = objectType << 3;
            config[0] |= (sampleIndex & 0x0E) >> 1;
            config[1] |= (sampleIndex & 0x01) << 7;
            config[1] |= channelCount << 3;

            this.track.codec = 'mp4a.40.' + objectType;
            this.track.channelCount = channelCount;
            this.track.config = config;
            this.remuxer.readyToDecode = true;
        }
    }]);
    return AACParser;
}();

var Event = function () {
    function Event(type) {
        classCallCheck(this, Event);

        this.listener = {};
        this.type = type | '';
    }

    createClass(Event, [{
        key: 'on',
        value: function on(event, fn) {
            if (!this.listener[event]) {
                this.listener[event] = [];
            }
            this.listener[event].push(fn);
            return true;
        }
    }, {
        key: 'off',
        value: function off(event, fn) {
            if (this.listener[event]) {
                var index = this.listener[event].indexOf(fn);
                if (index > -1) {
                    this.listener[event].splice(index, 1);
                }
                return true;
            }
            return false;
        }
    }, {
        key: 'offAll',
        value: function offAll() {
            this.listener = {};
        }
    }, {
        key: 'dispatch',
        value: function dispatch(event, data) {
            if (this.listener[event]) {
                this.listener[event].map(function (each) {
                    each.apply(null, [data]);
                });
                return true;
            }
            return false;
        }
    }]);
    return Event;
}();

/**
 * Generate MP4 Box
 * taken from: https://github.com/dailymotion/hls.js
 */

var MP4 = function () {
    function MP4() {
        classCallCheck(this, MP4);
    }

    createClass(MP4, null, [{
        key: 'init',
        value: function init() {
            MP4.types = {
                avc1: [], // codingname
                avcC: [],
                btrt: [],
                dinf: [],
                dref: [],
                esds: [],
                ftyp: [],
                hdlr: [],
                mdat: [],
                mdhd: [],
                mdia: [],
                mfhd: [],
                minf: [],
                moof: [],
                moov: [],
                mp4a: [],
                mvex: [],
                mvhd: [],
                sdtp: [],
                stbl: [],
                stco: [],
                stsc: [],
                stsd: [],
                stsz: [],
                stts: [],
                tfdt: [],
                tfhd: [],
                traf: [],
                trak: [],
                trun: [],
                trex: [],
                tkhd: [],
                vmhd: [],
                smhd: []
            };

            var i;
            for (i in MP4.types) {
                if (MP4.types.hasOwnProperty(i)) {
                    MP4.types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];
                }
            }

            var videoHdlr = new Uint8Array([0x00, // version 0
            0x00, 0x00, 0x00, // flags
            0x00, 0x00, 0x00, 0x00, // pre_defined
            0x76, 0x69, 0x64, 0x65, // handler_type: 'vide'
            0x00, 0x00, 0x00, 0x00, // reserved
            0x00, 0x00, 0x00, 0x00, // reserved
            0x00, 0x00, 0x00, 0x00, // reserved
            0x56, 0x69, 0x64, 0x65, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00]);

            var audioHdlr = new Uint8Array([0x00, // version 0
            0x00, 0x00, 0x00, // flags
            0x00, 0x00, 0x00, 0x00, // pre_defined
            0x73, 0x6f, 0x75, 0x6e, // handler_type: 'soun'
            0x00, 0x00, 0x00, 0x00, // reserved
            0x00, 0x00, 0x00, 0x00, // reserved
            0x00, 0x00, 0x00, 0x00, // reserved
            0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00]);

            MP4.HDLR_TYPES = {
                video: videoHdlr,
                audio: audioHdlr
            };

            var dref = new Uint8Array([0x00, // version 0
            0x00, 0x00, 0x00, // flags
            0x00, 0x00, 0x00, 0x01, // entry_count
            0x00, 0x00, 0x00, 0x0c, // entry_size
            0x75, 0x72, 0x6c, 0x20, // 'url' type
            0x00, // version 0
            0x00, 0x00, 0x01]);

            var stco = new Uint8Array([0x00, // version
            0x00, 0x00, 0x00, // flags
            0x00, 0x00, 0x00, 0x00]);

            MP4.STTS = MP4.STSC = MP4.STCO = stco;

            MP4.STSZ = new Uint8Array([0x00, // version
            0x00, 0x00, 0x00, // flags
            0x00, 0x00, 0x00, 0x00, // sample_size
            0x00, 0x00, 0x00, 0x00]);
            MP4.VMHD = new Uint8Array([0x00, // version
            0x00, 0x00, 0x01, // flags
            0x00, 0x00, // graphicsmode
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
            MP4.SMHD = new Uint8Array([0x00, // version
            0x00, 0x00, 0x00, // flags
            0x00, 0x00, // balance
            0x00, 0x00]);

            MP4.STSD = new Uint8Array([0x00, // version 0
            0x00, 0x00, 0x00, // flags
            0x00, 0x00, 0x00, 0x01]); // entry_count

            var majorBrand = new Uint8Array([105, 115, 111, 109]); // isom
            var avc1Brand = new Uint8Array([97, 118, 99, 49]); // avc1
            var minorVersion = new Uint8Array([0, 0, 0, 1]);

            MP4.FTYP = MP4.box(MP4.types.ftyp, majorBrand, minorVersion, majorBrand, avc1Brand);
            MP4.DINF = MP4.box(MP4.types.dinf, MP4.box(MP4.types.dref, dref));
        }
    }, {
        key: 'box',
        value: function box(type) {
            for (var _len = arguments.length, payload = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                payload[_key - 1] = arguments[_key];
            }

            var size = 8,
                i = payload.length,
                len = i,
                result;
            // calculate the total size we need to allocate
            while (i--) {
                size += payload[i].byteLength;
            }
            result = new Uint8Array(size);
            result[0] = size >> 24 & 0xff;
            result[1] = size >> 16 & 0xff;
            result[2] = size >> 8 & 0xff;
            result[3] = size & 0xff;
            result.set(type, 4);
            // copy the payload into the result
            for (i = 0, size = 8; i < len; ++i) {
                // copy payload[i] array @ offset size
                result.set(payload[i], size);
                size += payload[i].byteLength;
            }
            return result;
        }
    }, {
        key: 'hdlr',
        value: function hdlr(type) {
            return MP4.box(MP4.types.hdlr, MP4.HDLR_TYPES[type]);
        }
    }, {
        key: 'mdat',
        value: function mdat(data) {
            return MP4.box(MP4.types.mdat, data);
        }
    }, {
        key: 'mdhd',
        value: function mdhd(timescale, duration) {
            return MP4.box(MP4.types.mdhd, new Uint8Array([0x00, // version 0
            0x00, 0x00, 0x00, // flags
            0x00, 0x00, 0x00, 0x02, // creation_time
            0x00, 0x00, 0x00, 0x03, // modification_time
            timescale >> 24 & 0xFF, timescale >> 16 & 0xFF, timescale >> 8 & 0xFF, timescale & 0xFF, // timescale
            duration >> 24, duration >> 16 & 0xFF, duration >> 8 & 0xFF, duration & 0xFF, // duration
            0x55, 0xc4, // 'und' language (undetermined)
            0x00, 0x00]));
        }
    }, {
        key: 'mdia',
        value: function mdia(track) {
            return MP4.box(MP4.types.mdia, MP4.mdhd(track.timescale, track.duration), MP4.hdlr(track.type), MP4.minf(track));
        }
    }, {
        key: 'mfhd',
        value: function mfhd(sequenceNumber) {
            return MP4.box(MP4.types.mfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00, // flags
            sequenceNumber >> 24, sequenceNumber >> 16 & 0xFF, sequenceNumber >> 8 & 0xFF, sequenceNumber & 0xFF]) // sequence_number
            );
        }
    }, {
        key: 'minf',
        value: function minf(track) {
            if (track.type === 'audio') {
                return MP4.box(MP4.types.minf, MP4.box(MP4.types.smhd, MP4.SMHD), MP4.DINF, MP4.stbl(track));
            } else {
                return MP4.box(MP4.types.minf, MP4.box(MP4.types.vmhd, MP4.VMHD), MP4.DINF, MP4.stbl(track));
            }
        }
    }, {
        key: 'moof',
        value: function moof(sn, baseMediaDecodeTime, track) {
            return MP4.box(MP4.types.moof, MP4.mfhd(sn), MP4.traf(track, baseMediaDecodeTime));
        }
        /**
         * @param tracks... (optional) {array} the tracks associated with this movie
         */

    }, {
        key: 'moov',
        value: function moov(tracks, duration, timescale) {
            var i = tracks.length,
                boxes = [];

            while (i--) {
                boxes[i] = MP4.trak(tracks[i]);
            }

            return MP4.box.apply(null, [MP4.types.moov, MP4.mvhd(timescale, duration)].concat(boxes).concat(MP4.mvex(tracks)));
        }
    }, {
        key: 'mvex',
        value: function mvex(tracks) {
            var i = tracks.length,
                boxes = [];

            while (i--) {
                boxes[i] = MP4.trex(tracks[i]);
            }
            return MP4.box.apply(null, [MP4.types.mvex].concat(boxes));
        }
    }, {
        key: 'mvhd',
        value: function mvhd(timescale, duration) {
            var bytes = new Uint8Array([0x00, // version 0
            0x00, 0x00, 0x00, // flags
            0x00, 0x00, 0x00, 0x01, // creation_time
            0x00, 0x00, 0x00, 0x02, // modification_time
            timescale >> 24 & 0xFF, timescale >> 16 & 0xFF, timescale >> 8 & 0xFF, timescale & 0xFF, // timescale
            duration >> 24 & 0xFF, duration >> 16 & 0xFF, duration >> 8 & 0xFF, duration & 0xFF, // duration
            0x00, 0x01, 0x00, 0x00, // 1.0 rate
            0x01, 0x00, // 1.0 volume
            0x00, 0x00, // reserved
            0x00, 0x00, 0x00, 0x00, // reserved
            0x00, 0x00, 0x00, 0x00, // reserved
            0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // transformation: unity matrix
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pre_defined
            0xff, 0xff, 0xff, 0xff]);
            return MP4.box(MP4.types.mvhd, bytes);
        }
    }, {
        key: 'sdtp',
        value: function sdtp(track) {
            var samples = track.samples || [],
                bytes = new Uint8Array(4 + samples.length),
                flags,
                i;
            // leave the full box header (4 bytes) all zero
            // write the sample table
            for (i = 0; i < samples.length; i++) {
                flags = samples[i].flags;
                bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;
            }

            return MP4.box(MP4.types.sdtp, bytes);
        }
    }, {
        key: 'stbl',
        value: function stbl(track) {
            return MP4.box(MP4.types.stbl, MP4.stsd(track), MP4.box(MP4.types.stts, MP4.STTS), MP4.box(MP4.types.stsc, MP4.STSC), MP4.box(MP4.types.stsz, MP4.STSZ), MP4.box(MP4.types.stco, MP4.STCO));
        }
    }, {
        key: 'avc1',
        value: function avc1(track) {
            var sps = [],
                pps = [],
                i,
                data,
                len;
            // assemble the SPSs

            for (i = 0; i < track.sps.length; i++) {
                data = track.sps[i];
                len = data.byteLength;
                sps.push(len >>> 8 & 0xFF);
                sps.push(len & 0xFF);
                sps = sps.concat(Array.prototype.slice.call(data)); // SPS
            }

            // assemble the PPSs
            for (i = 0; i < track.pps.length; i++) {
                data = track.pps[i];
                len = data.byteLength;
                pps.push(len >>> 8 & 0xFF);
                pps.push(len & 0xFF);
                pps = pps.concat(Array.prototype.slice.call(data));
            }

            var avcc = MP4.box(MP4.types.avcC, new Uint8Array([0x01, // version
            sps[3], // profile
            sps[4], // profile compat
            sps[5], // level
            0xfc | 3, // lengthSizeMinusOne, hard-coded to 4 bytes
            0xE0 | track.sps.length].concat(sps).concat([track.pps.length] // numOfPictureParameterSets
            ).concat(pps))),
                // "PPS"
            width = track.width,
                height = track.height;
            // console.log('avcc:' + Hex.hexDump(avcc));
            return MP4.box(MP4.types.avc1, new Uint8Array([0x00, 0x00, 0x00, // reserved
            0x00, 0x00, 0x00, // reserved
            0x00, 0x01, // data_reference_index
            0x00, 0x00, // pre_defined
            0x00, 0x00, // reserved
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pre_defined
            width >> 8 & 0xFF, width & 0xff, // width
            height >> 8 & 0xFF, height & 0xff, // height
            0x00, 0x48, 0x00, 0x00, // horizresolution
            0x00, 0x48, 0x00, 0x00, // vertresolution
            0x00, 0x00, 0x00, 0x00, // reserved
            0x00, 0x01, // frame_count
            0x12, 0x62, 0x69, 0x6E, 0x65, // binelpro.ru
            0x6C, 0x70, 0x72, 0x6F, 0x2E, 0x72, 0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // compressorname
            0x00, 0x18, // depth = 24
            0x11, 0x11]), // pre_defined = -1
            avcc, MP4.box(MP4.types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80, // bufferSizeDB
            0x00, 0x2d, 0xc6, 0xc0, // maxBitrate
            0x00, 0x2d, 0xc6, 0xc0])) // avgBitrate
            );
        }
    }, {
        key: 'esds',
        value: function esds(track) {
            var configlen = track.config.byteLength;
            var data = new Uint8Array(26 + configlen + 3);
            data.set([0x00, // version 0
            0x00, 0x00, 0x00, // flags

            0x03, // descriptor_type
            0x17 + configlen, // length
            0x00, 0x01, // es_id
            0x00, // stream_priority

            0x04, // descriptor_type
            0x0f + configlen, // length
            0x40, // codec : mpeg4_audio
            0x15, // stream_type
            0x00, 0x00, 0x00, // buffer_size
            0x00, 0x00, 0x00, 0x00, // maxBitrate
            0x00, 0x00, 0x00, 0x00, // avgBitrate

            0x05, // descriptor_type
            configlen]);
            data.set(track.config, 26);
            data.set([0x06, 0x01, 0x02], 26 + configlen);
            // return new Uint8Array([
            //     0x00, // version 0
            //     0x00, 0x00, 0x00, // flags
            //
            //     0x03, // descriptor_type
            //     0x17+configlen, // length
            //     0x00, 0x01, //es_id
            //     0x00, // stream_priority
            //
            //     0x04, // descriptor_type
            //     0x0f+configlen, // length
            //     0x40, //codec : mpeg4_audio
            //     0x15, // stream_type
            //     0x00, 0x00, 0x00, // buffer_size
            //     0x00, 0x00, 0x00, 0x00, // maxBitrate
            //     0x00, 0x00, 0x00, 0x00, // avgBitrate
            //
            //     0x05 // descriptor_type
            // ].concat([configlen]).concat(track.config).concat([0x06, 0x01, 0x02])); // GASpecificConfig)); // length + audio config descriptor
            return data;
        }
    }, {
        key: 'mp4a',
        value: function mp4a(track) {
            var audiosamplerate = track.audiosamplerate;
            return MP4.box(MP4.types.mp4a, new Uint8Array([0x00, 0x00, 0x00, // reserved
            0x00, 0x00, 0x00, // reserved
            0x00, 0x01, // data_reference_index
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved
            0x00, track.channelCount, // channelcount
            0x00, 0x10, // sampleSize:16bits
            0x00, 0x00, // pre_defined
            0x00, 0x00, // reserved2
            audiosamplerate >> 8 & 0xFF, audiosamplerate & 0xff, //
            0x00, 0x00]), MP4.box(MP4.types.esds, MP4.esds(track)));
        }
    }, {
        key: 'stsd',
        value: function stsd(track) {
            if (track.type === 'audio') {
                return MP4.box(MP4.types.stsd, MP4.STSD, MP4.mp4a(track));
            } else {
                return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
            }
        }
    }, {
        key: 'tkhd',
        value: function tkhd(track) {
            var id = track.id,
                duration = track.duration,
                width = track.width,
                height = track.height,
                volume = track.volume;
            return MP4.box(MP4.types.tkhd, new Uint8Array([0x00, // version 0
            0x00, 0x00, 0x07, // flags
            0x00, 0x00, 0x00, 0x00, // creation_time
            0x00, 0x00, 0x00, 0x00, // modification_time
            id >> 24 & 0xFF, id >> 16 & 0xFF, id >> 8 & 0xFF, id & 0xFF, // track_ID
            0x00, 0x00, 0x00, 0x00, // reserved
            duration >> 24, duration >> 16 & 0xFF, duration >> 8 & 0xFF, duration & 0xFF, // duration
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved
            0x00, 0x00, // layer
            0x00, 0x00, // alternate_group
            volume >> 0 & 0xff, volume % 1 * 10 >> 0 & 0xff, // track volume // FIXME
            0x00, 0x00, // reserved
            0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // transformation: unity matrix
            width >> 8 & 0xFF, width & 0xFF, 0x00, 0x00, // width
            height >> 8 & 0xFF, height & 0xFF, 0x00, 0x00]) // height
            );
        }
    }, {
        key: 'traf',
        value: function traf(track, baseMediaDecodeTime) {
            var sampleDependencyTable = MP4.sdtp(track),
                id = track.id;
            return MP4.box(MP4.types.traf, MP4.box(MP4.types.tfhd, new Uint8Array([0x00, // version 0
            0x00, 0x00, 0x00, // flags
            id >> 24, id >> 16 & 0XFF, id >> 8 & 0XFF, id & 0xFF]) // track_ID
            ), MP4.box(MP4.types.tfdt, new Uint8Array([0x00, // version 0
            0x00, 0x00, 0x00, // flags
            baseMediaDecodeTime >> 24, baseMediaDecodeTime >> 16 & 0XFF, baseMediaDecodeTime >> 8 & 0XFF, baseMediaDecodeTime & 0xFF]) // baseMediaDecodeTime
            ), MP4.trun(track, sampleDependencyTable.length + 16 + // tfhd
            16 + // tfdt
            8 + // traf header
            16 + // mfhd
            8 + // moof header
            8), // mdat header
            sampleDependencyTable);
        }

        /**
         * Generate a track box.
         * @param track {object} a track definition
         * @return {Uint8Array} the track box
         */

    }, {
        key: 'trak',
        value: function trak(track) {
            track.duration = track.duration || 0xffffffff;
            return MP4.box(MP4.types.trak, MP4.tkhd(track), MP4.mdia(track));
        }
    }, {
        key: 'trex',
        value: function trex(track) {
            var id = track.id;
            return MP4.box(MP4.types.trex, new Uint8Array([0x00, // version 0
            0x00, 0x00, 0x00, // flags
            id >> 24, id >> 16 & 0XFF, id >> 8 & 0XFF, id & 0xFF, // track_ID
            0x00, 0x00, 0x00, 0x01, // default_sample_description_index
            0x00, 0x00, 0x00, 0x00, // default_sample_duration
            0x00, 0x00, 0x00, 0x00, // default_sample_size
            0x00, 0x01, 0x00, 0x01]) // default_sample_flags
            );
        }
    }, {
        key: 'trun',
        value: function trun(track, offset) {
            var samples = track.samples || [],
                len = samples.length,
                arraylen = 12 + 16 * len,
                array = new Uint8Array(arraylen),
                i,
                sample,
                duration,
                size,
                flags,
                cts;
            offset += 8 + arraylen;
            array.set([0x00, // version 0
            0x00, 0x0f, 0x01, // flags
            len >>> 24 & 0xFF, len >>> 16 & 0xFF, len >>> 8 & 0xFF, len & 0xFF, // sample_count
            offset >>> 24 & 0xFF, offset >>> 16 & 0xFF, offset >>> 8 & 0xFF, offset & 0xFF], 0);
            for (i = 0; i < len; i++) {
                sample = samples[i];
                duration = sample.duration;
                size = sample.size;
                flags = sample.flags;
                cts = sample.cts;
                array.set([duration >>> 24 & 0xFF, duration >>> 16 & 0xFF, duration >>> 8 & 0xFF, duration & 0xFF, // sample_duration
                size >>> 24 & 0xFF, size >>> 16 & 0xFF, size >>> 8 & 0xFF, size & 0xFF, // sample_size
                flags.isLeading << 2 | flags.dependsOn, flags.isDependedOn << 6 | flags.hasRedundancy << 4 | flags.paddingValue << 1 | flags.isNonSync, flags.degradPrio & 0xF0 << 8, flags.degradPrio & 0x0F, // sample_flags
                cts >>> 24 & 0xFF, cts >>> 16 & 0xFF, cts >>> 8 & 0xFF, cts & 0xFF], 12 + 16 * i);
            }
            return MP4.box(MP4.types.trun, array);
        }
    }, {
        key: 'initSegment',
        value: function initSegment(tracks, duration, timescale) {
            if (!MP4.types) {
                MP4.init();
            }
            var movie = MP4.moov(tracks, duration, timescale),
                result;
            result = new Uint8Array(MP4.FTYP.byteLength + movie.byteLength);
            result.set(MP4.FTYP);
            result.set(movie, MP4.FTYP.byteLength);
            return result;
        }
    }]);
    return MP4;
}();

var track_id = 1;
var BaseRemuxer = function () {
    createClass(BaseRemuxer, null, [{
        key: 'getTrackID',
        value: function getTrackID() {
            return track_id++;
        }
    }]);

    function BaseRemuxer() {
        classCallCheck(this, BaseRemuxer);

        this.seq = 1;
    }

    createClass(BaseRemuxer, [{
        key: 'flush',
        value: function flush() {
            this.seq++;
            this.mp4track.len = 0;
            this.mp4track.samples = [];
        }
    }, {
        key: 'isReady',
        value: function isReady() {
            if (!this.readyToDecode || !this.samples.length) return null;
            return true;
        }
    }]);
    return BaseRemuxer;
}();

var AACRemuxer = function (_BaseRemuxer) {
    inherits(AACRemuxer, _BaseRemuxer);

    function AACRemuxer() {
        classCallCheck(this, AACRemuxer);

        var _this = possibleConstructorReturn(this, (AACRemuxer.__proto__ || Object.getPrototypeOf(AACRemuxer)).call(this));

        _this.readyToDecode = false;
        _this.nextDts = 0;
        _this.dts = 0;
        _this.timescale = 1000;

        _this.mp4track = {
            id: BaseRemuxer.getTrackID(),
            type: 'audio',
            channelCount: 0,
            len: 0,
            fragmented: true,
            timescale: _this.timescale,
            duration: _this.timescale,
            samples: [],
            config: '',
            codec: ''
        };

        _this.samples = [];
        _this.aac = new AACParser(_this);
        return _this;
    }

    createClass(AACRemuxer, [{
        key: 'resetTrack',
        value: function resetTrack() {
            this.readyToDecode = false;
            this.mp4track.codec = '';
            this.mp4track.channelCount = '';
            this.mp4track.config = '';
            this.mp4track.timescale = this.timescale;
        }
    }, {
        key: 'remux',
        value: function remux(samples) {
            var config = void 0,
                sample = void 0,
                size = void 0,
                payload = void 0;
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = samples[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var _sample = _step.value;

                    payload = _sample.units;
                    size = payload.byteLength;
                    this.samples.push({
                        units: payload,
                        size: size,
                        duration: _sample.duration
                    });
                    this.mp4track.len += size;
                    if (!this.readyToDecode) {
                        this.aac.setAACConfig();
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }
    }, {
        key: 'getPayload',
        value: function getPayload() {
            if (!this.isReady()) {
                return null;
            }

            var payload = new Uint8Array(this.mp4track.len);
            var offset = 0;
            var samples = this.mp4track.samples;
            var mp4Sample = void 0,
                duration = void 0;

            this.dts = this.nextDts;

            while (this.samples.length) {
                var sample = this.samples.shift();

                duration = sample.duration;

                if (duration <= 0) {
                    log('remuxer: invalid sample duration at DTS: ' + this.nextDts + ' :' + duration);
                    this.mp4track.len -= sample.size;
                    continue;
                }

                this.nextDts += duration;
                mp4Sample = {
                    size: sample.size,
                    duration: duration,
                    cts: 0,
                    flags: {
                        isLeading: 0,
                        isDependedOn: 0,
                        hasRedundancy: 0,
                        degradPrio: 0,
                        dependsOn: 1
                    }
                };

                payload.set(sample.units, offset);
                offset += sample.size;
                samples.push(mp4Sample);
            }

            if (!samples.length) return null;

            return new Uint8Array(payload.buffer, 0, this.mp4track.len);
        }
    }]);
    return AACRemuxer;
}(BaseRemuxer);

var H264Remuxer = function (_BaseRemuxer) {
    inherits(H264Remuxer, _BaseRemuxer);

    function H264Remuxer() {
        classCallCheck(this, H264Remuxer);

        var _this = possibleConstructorReturn(this, (H264Remuxer.__proto__ || Object.getPrototypeOf(H264Remuxer)).call(this));

        _this.readyToDecode = false;
        _this.nextDts = 0;
        _this.dts = 0;
        _this.timescale = 1000;

        _this.mp4track = {
            id: BaseRemuxer.getTrackID(),
            type: 'video',
            len: 0,
            fragmented: true,
            sps: '',
            pps: '',
            width: 0,
            height: 0,
            timescale: _this.timescale,
            duration: _this.timescale,
            samples: []
        };

        _this.samples = [];
        _this.h264 = new H264Parser(_this);
        return _this;
    }

    createClass(H264Remuxer, [{
        key: 'resetTrack',
        value: function resetTrack() {
            this.readyToDecode = false;
            this.mp4track.sps = '';
            this.mp4track.pps = '';
        }
    }, {
        key: 'remux',
        value: function remux(samples) {
            var sample = void 0,
                units = void 0,
                unit = void 0,
                size = void 0,
                keyFrame = void 0;
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = samples[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    sample = _step.value;

                    units = [];
                    size = 0;
                    keyFrame = false;
                    var _iteratorNormalCompletion2 = true;
                    var _didIteratorError2 = false;
                    var _iteratorError2 = undefined;

                    try {
                        for (var _iterator2 = sample.units[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                            unit = _step2.value;

                            if (this.h264.parseNAL(unit)) {
                                units.push(unit);
                                size += unit.getSize();
                                if (!keyFrame) {
                                    keyFrame = unit.isKeyframe();
                                }
                            }
                        }
                    } catch (err) {
                        _didIteratorError2 = true;
                        _iteratorError2 = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                _iterator2.return();
                            }
                        } finally {
                            if (_didIteratorError2) {
                                throw _iteratorError2;
                            }
                        }
                    }

                    if (units.length > 0 && this.readyToDecode) {
                        this.mp4track.len += size;
                        this.samples.push({
                            units: units,
                            size: size,
                            keyFrame: keyFrame,
                            duration: sample.duration
                        });
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }
    }, {
        key: 'getPayload',
        value: function getPayload() {
            if (!this.isReady()) {
                return null;
            }

            var payload = new Uint8Array(this.mp4track.len);
            var offset = 0;
            var samples = this.mp4track.samples;
            var mp4Sample = void 0,
                duration = void 0;

            this.dts = this.nextDts;

            while (this.samples.length) {
                var sample = this.samples.shift(),
                    units = sample.units;

                duration = sample.duration;

                if (duration <= 0) {
                    log('remuxer: invalid sample duration at DTS: ' + this.nextDts + ' :' + duration);
                    this.mp4track.len -= sample.size;
                    continue;
                }

                this.nextDts += duration;
                mp4Sample = {
                    size: sample.size,
                    duration: duration,
                    cts: 0,
                    flags: {
                        isLeading: 0,
                        isDependedOn: 0,
                        hasRedundancy: 0,
                        degradPrio: 0,
                        isNonSync: sample.keyFrame ? 0 : 1,
                        dependsOn: sample.keyFrame ? 2 : 1
                    }
                };

                var _iteratorNormalCompletion3 = true;
                var _didIteratorError3 = false;
                var _iteratorError3 = undefined;

                try {
                    for (var _iterator3 = units[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                        var unit = _step3.value;

                        payload.set(unit.getData(), offset);
                        offset += unit.getSize();
                    }
                } catch (err) {
                    _didIteratorError3 = true;
                    _iteratorError3 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion3 && _iterator3.return) {
                            _iterator3.return();
                        }
                    } finally {
                        if (_didIteratorError3) {
                            throw _iteratorError3;
                        }
                    }
                }

                samples.push(mp4Sample);
            }

            if (!samples.length) return null;

            return new Uint8Array(payload.buffer, 0, this.mp4track.len);
        }
    }]);
    return H264Remuxer;
}(BaseRemuxer);

function appendByteArray(buffer1, buffer2) {
    var tmp = new Uint8Array((buffer1.byteLength | 0) + (buffer2.byteLength | 0));
    tmp.set(buffer1, 0);
    tmp.set(buffer2, buffer1.byteLength | 0);
    return tmp;
}

function secToTime(sec) {
    var seconds = void 0,
        hours = void 0,
        minutes = void 0,
        result = '';

    seconds = Math.floor(sec);
    hours = parseInt(seconds / 3600, 10) % 24;
    minutes = parseInt(seconds / 60, 10) % 60;
    seconds = seconds < 0 ? 0 : seconds % 60;

    if (hours > 0) {
        result += (hours < 10 ? '0' + hours : hours) + ':';
    }
    result += (minutes < 10 ? '0' + minutes : minutes) + ':' + (seconds < 10 ? '0' + seconds : seconds);
    return result;
}

var RemuxController = function (_Event) {
    inherits(RemuxController, _Event);

    function RemuxController(streaming) {
        classCallCheck(this, RemuxController);

        var _this = possibleConstructorReturn(this, (RemuxController.__proto__ || Object.getPrototypeOf(RemuxController)).call(this, 'remuxer'));

        _this.initialized = false;
        _this.trackTypes = [];
        _this.tracks = {};
        _this.mediaDuration = streaming ? Infinity : 1000;
        return _this;
    }

    createClass(RemuxController, [{
        key: 'addTrack',
        value: function addTrack(type) {
            if (type === 'video' || type === 'both') {
                this.tracks.video = new H264Remuxer();
                this.trackTypes.push('video');
            }
            if (type === 'audio' || type === 'both') {
                this.tracks.audio = new AACRemuxer();
                this.trackTypes.push('audio');
            }
        }
    }, {
        key: 'reset',
        value: function reset() {
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = this.trackTypes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var type = _step.value;

                    this.tracks[type].resetTrack();
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            this.initialized = false;
        }
    }, {
        key: 'destroy',
        value: function destroy() {
            this.tracks = {};
            this.offAll();
        }
    }, {
        key: 'flush',
        value: function flush() {
            if (!this.initialized) {
                if (this.isReady()) {
                    this.dispatch('ready');
                    var _iteratorNormalCompletion2 = true;
                    var _didIteratorError2 = false;
                    var _iteratorError2 = undefined;

                    try {
                        for (var _iterator2 = this.trackTypes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                            var type = _step2.value;

                            var track = this.tracks[type];
                            var data = {
                                type: type,
                                payload: MP4.initSegment([track.mp4track], this.mediaDuration, track.mp4track.timescale)
                            };
                            this.dispatch('buffer', data);
                        }
                    } catch (err) {
                        _didIteratorError2 = true;
                        _iteratorError2 = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                _iterator2.return();
                            }
                        } finally {
                            if (_didIteratorError2) {
                                throw _iteratorError2;
                            }
                        }
                    }

                    log('Initial segment generated.');
                    this.initialized = true;
                }
            } else {
                var _iteratorNormalCompletion3 = true;
                var _didIteratorError3 = false;
                var _iteratorError3 = undefined;

                try {
                    for (var _iterator3 = this.trackTypes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                        var _type = _step3.value;

                        var _track = this.tracks[_type];
                        var pay = _track.getPayload();
                        if (pay && pay.byteLength) {
                            var moof = MP4.moof(_track.seq, _track.dts, _track.mp4track);
                            var mdat = MP4.mdat(pay);
                            var payload = appendByteArray(moof, mdat);
                            var _data = {
                                type: _type,
                                payload: payload,
                                dts: _track.dts
                            };
                            this.dispatch('buffer', _data);
                            var duration = secToTime(_track.dts / 1000);
                            log('put segment (' + _type + '): ' + _track.seq + ' dts: ' + _track.dts + ' samples: ' + _track.mp4track.samples.length + ' second: ' + duration);
                            _track.flush();
                        }
                    }
                } catch (err) {
                    _didIteratorError3 = true;
                    _iteratorError3 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion3 && _iterator3.return) {
                            _iterator3.return();
                        }
                    } finally {
                        if (_didIteratorError3) {
                            throw _iteratorError3;
                        }
                    }
                }
            }
        }
    }, {
        key: 'isReady',
        value: function isReady() {
            var _iteratorNormalCompletion4 = true;
            var _didIteratorError4 = false;
            var _iteratorError4 = undefined;

            try {
                for (var _iterator4 = this.trackTypes[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                    var type = _step4.value;

                    if (!this.tracks[type].readyToDecode || !this.tracks[type].samples.length) return false;
                }
            } catch (err) {
                _didIteratorError4 = true;
                _iteratorError4 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion4 && _iterator4.return) {
                        _iterator4.return();
                    }
                } finally {
                    if (_didIteratorError4) {
                        throw _iteratorError4;
                    }
                }
            }

            return true;
        }
    }, {
        key: 'remux',
        value: function remux(data) {
            var _iteratorNormalCompletion5 = true;
            var _didIteratorError5 = false;
            var _iteratorError5 = undefined;

            try {
                for (var _iterator5 = this.trackTypes[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
                    var type = _step5.value;

                    var samples = data[type];
                    if (type === 'audio' && this.tracks.video && !this.tracks.video.readyToDecode) continue; /* if video is present, don't add audio until video get ready */
                    if (samples.length > 0) {
                        this.tracks[type].remux(samples);
                    }
                }
            } catch (err) {
                _didIteratorError5 = true;
                _iteratorError5 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion5 && _iterator5.return) {
                        _iterator5.return();
                    }
                } finally {
                    if (_didIteratorError5) {
                        throw _iteratorError5;
                    }
                }
            }

            this.flush();
        }
    }]);
    return RemuxController;
}(Event);

var BufferController = function (_Event) {
    inherits(BufferController, _Event);

    function BufferController(sourceBuffer, type) {
        classCallCheck(this, BufferController);

        var _this = possibleConstructorReturn(this, (BufferController.__proto__ || Object.getPrototypeOf(BufferController)).call(this, 'buffer'));

        _this.type = type;
        _this.queue = new Uint8Array();

        _this.cleaning = false;
        _this.pendingCleaning = 0;
        _this.cleanOffset = 30;
        _this.cleanRanges = [];

        _this.sourceBuffer = sourceBuffer;
        _this.sourceBuffer.addEventListener('updateend', function () {
            if (_this.pendingCleaning > 0) {
                _this.initCleanup(_this.pendingCleaning);
                _this.pendingCleaning = 0;
            }
            _this.cleaning = false;
            if (_this.cleanRanges.length) {
                _this.doCleanup();
                return;
            }
        });

        _this.sourceBuffer.addEventListener('error', function () {
            _this.dispatch('error', { type: _this.type, name: 'buffer', error: 'buffer error' });
        });
        return _this;
    }

    createClass(BufferController, [{
        key: 'destroy',
        value: function destroy() {
            this.queue = null;
            this.sourceBuffer = null;
            this.offAll();
        }
    }, {
        key: 'doCleanup',
        value: function doCleanup() {
            if (!this.cleanRanges.length) {
                this.cleaning = false;
                return;
            }
            var range = this.cleanRanges.shift();
            log(this.type + ' remove range [' + range[0] + ' - ' + range[1] + ')');
            this.cleaning = true;
            this.sourceBuffer.remove(range[0], range[1]);
        }
    }, {
        key: 'initCleanup',
        value: function initCleanup(cleanMaxLimit) {
            if (this.sourceBuffer.updating) {
                this.pendingCleaning = cleanMaxLimit;
                return;
            }
            if (this.sourceBuffer.buffered && this.sourceBuffer.buffered.length && !this.cleaning) {
                for (var i = 0; i < this.sourceBuffer.buffered.length; ++i) {
                    var start = this.sourceBuffer.buffered.start(i);
                    var end = this.sourceBuffer.buffered.end(i);

                    if (cleanMaxLimit - start > this.cleanOffset) {
                        end = cleanMaxLimit - this.cleanOffset;
                        if (start < end) {
                            this.cleanRanges.push([start, end]);
                        }
                    }
                }
                this.doCleanup();
            }
        }
    }, {
        key: 'doAppend',
        value: function doAppend() {
            if (!this.queue.length) return;

            if (this.sourceBuffer.updating) {
                return;
            }

            try {
                this.sourceBuffer.appendBuffer(this.queue);
                this.queue = new Uint8Array();
            } catch (e) {
                if (e.name === 'QuotaExceededError') {
                    log(this.type + ' buffer quota full');
                    this.dispatch('error', { type: this.type, name: 'QuotaExceeded', error: 'buffer error' });
                    return;
                }
                error('Error occured while appending ' + this.type + ' buffer -  ' + e.name + ': ' + e.message);
                this.dispatch('error', { type: this.type, name: 'unexpectedError', error: 'buffer error' });
            }
        }
    }, {
        key: 'feed',
        value: function feed(data) {
            this.queue = appendByteArray(this.queue, data);
        }
    }]);
    return BufferController;
}(Event);

window.MediaSource = window.MediaSource || window.WebKitMediaSource;

var JMuxmer = function (_Event) {
    inherits(JMuxmer, _Event);
    createClass(JMuxmer, null, [{
        key: 'isSupported',
        value: function isSupported(codec) {
            return window.MediaSource && window.MediaSource.isTypeSupported(codec);
        }
    }]);

    function JMuxmer(options) {
        classCallCheck(this, JMuxmer);

        var _this = possibleConstructorReturn(this, (JMuxmer.__proto__ || Object.getPrototypeOf(JMuxmer)).call(this, 'jmuxer'));

        window.MediaSource = window.MediaSource || window.WebKitMediaSource;

        var defaults$$1 = {
            node: '',
            mode: 'both', // both, audio, video
            flushingTime: 1500,
            clearBuffer: true,
            onReady: null, // function called when MSE is ready to accept frames
            fps: 30,
            debug: false
        };
        _this.options = Object.assign({}, defaults$$1, options);

        if (_this.options.debug) {
            setLogger();
        }

        if (typeof _this.options.node === 'string' && _this.options.node == '') {
            error('no video element were found to render, provide a valid video element');
        }

        if (!_this.options.fps) {
            _this.options.fps = 30;
        }
        _this.frameDuration = 1000 / _this.options.fps | 0;

        _this.node = typeof _this.options.node === 'string' ? document.getElementById(_this.options.node) : _this.options.node;

        _this.sourceBuffers = {};
        _this.isMSESupported = !!window.MediaSource;

        if (!_this.isMSESupported) {
            throw 'Oops! Browser does not support media source extension.';
        }

        _this.setupMSE();
        _this.remuxController = new RemuxController(_this.options.clearBuffer);
        _this.remuxController.addTrack(_this.options.mode);

        _this.mseReady = false;
        _this.lastCleaningTime = Date.now();
        _this.keyframeCache = [];
        _this.frameCounter = 0;

        /* events callback */
        _this.remuxController.on('buffer', _this.onBuffer.bind(_this));
        _this.remuxController.on('ready', _this.createBuffer.bind(_this));
        _this.startInterval();
        return _this;
    }

    createClass(JMuxmer, [{
        key: 'setupMSE',
        value: function setupMSE() {
            this.mediaSource = new MediaSource();
            this.node.src = URL.createObjectURL(this.mediaSource);
            this.mediaSource.addEventListener('sourceopen', this.onMSEOpen.bind(this));
            this.mediaSource.addEventListener('sourceclose', this.onMSEClose.bind(this));
            this.mediaSource.addEventListener('webkitsourceopen', this.onMSEOpen.bind(this));
            this.mediaSource.addEventListener('webkitsourceclose', this.onMSEClose.bind(this));
        }
    }, {
        key: 'feed',
        value: function feed(data) {
            var remux = false,
                nalus = void 0,
                aacFrames = void 0,
                duration = void 0,
                chunks = {
                video: [],
                audio: []
            };

            if (!data || !this.remuxController) return;
            duration = data.duration ? parseInt(data.duration) : 0;
            if (data.video) {
                nalus = H264Parser.extractNALu(data.video);
                if (nalus.length > 0) {
                    chunks.video = this.getVideoFrames(nalus, duration);
                    remux = true;
                }
            }
            if (data.audio) {
                aacFrames = AACParser.extractAAC(data.audio);
                if (aacFrames.length > 0) {
                    chunks.audio = this.getAudioFrames(aacFrames, duration);
                    remux = true;
                }
            }
            if (!remux) {
                error('Input object must have video and/or audio property. Make sure it is not empty and valid typed array');
                return;
            }
            this.remuxController.remux(chunks);
        }
    }, {
        key: 'getVideoFrames',
        value: function getVideoFrames(nalus, duration) {
            var nalu = void 0,
                units = [],
                samples = [],
                naluObj = void 0,
                sampleDuration = void 0,
                adjustDuration = 0,
                numberOfFrames = [];

            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = nalus[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    nalu = _step.value;

                    naluObj = new NALU(nalu);
                    units.push(naluObj);
                    if (naluObj.type() === NALU.IDR || naluObj.type() === NALU.NDR) {
                        samples.push({ units: units });
                        units = [];
                        if (this.options.clearBuffer) {
                            if (naluObj.type() === NALU.IDR) {
                                numberOfFrames.push(this.frameCounter);
                            }
                            this.frameCounter++;
                        }
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            if (duration) {
                sampleDuration = duration / samples.length | 0;
                adjustDuration = duration - sampleDuration * samples.length;
            } else {
                sampleDuration = this.frameDuration;
            }
            samples.map(function (sample) {
                sample.duration = adjustDuration > 0 ? sampleDuration + 1 : sampleDuration;
                if (adjustDuration !== 0) {
                    adjustDuration--;
                }
            });

            /* cache keyframe times if clearBuffer set true */
            if (this.options.clearBuffer) {
                numberOfFrames = numberOfFrames.map(function (total) {
                    return total * sampleDuration / 1000;
                });
                this.keyframeCache = this.keyframeCache.concat(numberOfFrames);
            }
            return samples;
        }
    }, {
        key: 'getAudioFrames',
        value: function getAudioFrames(aacFrames, duration) {
            var samples = [],
                units = void 0,
                sampleDuration = void 0,
                adjustDuration = 0;

            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = aacFrames[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    units = _step2.value;

                    samples.push({ units: units });
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }

            if (duration) {
                sampleDuration = duration / samples.length | 0;
                adjustDuration = duration - sampleDuration * samples.length;
            } else {
                sampleDuration = this.frameDuration;
            }
            samples.map(function (sample) {
                sample.duration = adjustDuration > 0 ? sampleDuration + 1 : sampleDuration;
                if (adjustDuration !== 0) {
                    adjustDuration--;
                }
            });
            return samples;
        }
    }, {
        key: 'destroy',
        value: function destroy() {
            this.stopInterval();
            if (this.mediaSource) {
                try {
                    if (this.bufferControllers) {
                        this.mediaSource.endOfStream();
                    }
                } catch (e) {
                    error('mediasource is not available to end ' + e.message);
                }
                this.mediaSource = null;
            }
            if (this.remuxController) {
                this.remuxController.destroy();
                this.remuxController = null;
            }
            if (this.bufferControllers) {
                for (var type in this.bufferControllers) {
                    this.bufferControllers[type].destroy();
                }
                this.bufferControllers = null;
            }
            this.node = false;
            this.mseReady = false;
            this.videoStarted = false;
        }
    }, {
        key: 'createBuffer',
        value: function createBuffer() {
            if (!this.mseReady || !this.remuxController || !this.remuxController.isReady() || this.bufferControllers) return;
            this.bufferControllers = {};
            for (var type in this.remuxController.tracks) {
                var track = this.remuxController.tracks[type];
                if (!JMuxmer.isSupported(type + '/mp4; codecs="' + track.mp4track.codec + '"')) {
                    error('Browser does not support codec');
                    return false;
                }
                var sb = this.mediaSource.addSourceBuffer(type + '/mp4; codecs="' + track.mp4track.codec + '"');
                this.bufferControllers[type] = new BufferController(sb, type);
                this.sourceBuffers[type] = sb;
                this.bufferControllers[type].on('error', this.onBufferError.bind(this));
            }
        }
    }, {
        key: 'startInterval',
        value: function startInterval() {
            var _this2 = this;

            this.interval = setInterval(function () {
                if (_this2.bufferControllers) {
                    _this2.releaseBuffer();
                    _this2.clearBuffer();
                }
            }, this.options.flushingTime);
        }
    }, {
        key: 'stopInterval',
        value: function stopInterval() {
            if (this.interval) {
                clearInterval(this.interval);
            }
        }
    }, {
        key: 'releaseBuffer',
        value: function releaseBuffer() {
            for (var type in this.bufferControllers) {
                this.bufferControllers[type].doAppend();
            }
        }
    }, {
        key: 'getSafeBufferClearLimit',
        value: function getSafeBufferClearLimit(offset) {
            var maxLimit = this.options.mode === 'audio' && offset || 0,
                adjacentOffset = void 0;

            for (var i = 0; i < this.keyframeCache.length; i++) {
                if (this.keyframeCache[i] >= offset) {
                    break;
                }
                adjacentOffset = this.keyframeCache[i];
            }

            if (adjacentOffset) {
                this.keyframeCache = this.keyframeCache.filter(function (keyframePoint) {
                    if (keyframePoint < adjacentOffset) {
                        maxLimit = keyframePoint;
                    }
                    return keyframePoint >= adjacentOffset;
                });
            }

            return maxLimit;
        }
    }, {
        key: 'clearBuffer',
        value: function clearBuffer() {
            if (this.options.clearBuffer && Date.now() - this.lastCleaningTime > 10000) {
                for (var type in this.bufferControllers) {
                    var cleanMaxLimit = this.getSafeBufferClearLimit(this.node.currentTime);
                    this.bufferControllers[type].initCleanup(cleanMaxLimit);
                }
                this.lastCleaningTime = Date.now();
            }
        }
    }, {
        key: 'onBuffer',
        value: function onBuffer(data) {
            if (this.bufferControllers && this.bufferControllers[data.type]) {
                this.bufferControllers[data.type].feed(data.payload);
            }
        }

        /* Events on MSE */

    }, {
        key: 'onMSEOpen',
        value: function onMSEOpen() {
            this.mseReady = true;
            if (typeof this.options.onReady === 'function') {
                this.options.onReady();
                this.options.onReady = null;
            }
            this.createBuffer();
        }
    }, {
        key: 'onMSEClose',
        value: function onMSEClose() {
            this.mseReady = false;
            this.videoStarted = false;
        }
    }, {
        key: 'onBufferError',
        value: function onBufferError(data) {
            if (data.name == 'QuotaExceeded') {
                this.bufferControllers[data.type].initCleanup(this.node.currentTime);
                return;
            }

            if (this.mediaSource.sourceBuffers.length > 0 && this.sourceBuffers[data.type]) {
                this.mediaSource.removeSourceBuffer(this.sourceBuffers[data.type]);
            }
            if (this.mediaSource.sourceBuffers.length == 0) {
                try {
                    this.mediaSource.endOfStream();
                } catch (e) {
                    error('mediasource is not available to end');
                }
            }
        }
    }]);
    return JMuxmer;
}(Event);

return JMuxmer;

})));