Simulator first commit

node_modules/mumble-client-codecs-node/lib/decode-worker.js

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (self) {
+  var opusDecoder;
+  self.addEventListener('message', function (e) {
+    var data = e.data;
+    if (data.action === 'reset') {
+      if (opusDecoder) {
+        opusDecoder.destroy();
+        opusDecoder = null;
+      }
+      self.postMessage({
+        action: 'reset'
+      });
+    } else if (data.action === 'decodeOpus') {
+      if (!opusDecoder) {
+        opusDecoder = new _libopus.Decoder({
+          unsafe: true,
+          channels: 1, // TODO
+          rate: MUMBLE_SAMPLE_RATE
+        });
+      }
+      var input = data.buffer ? Buffer.from(data.buffer) : null;
+      var decoded = opusDecoder.decodeFloat32(input);
+      self.postMessage({
+        action: 'decoded',
+        buffer: decoded.buffer,
+        target: data.target,
+        position: data.position
+      }, [decoded.buffer]);
+    }
+  });
+};
+
+var _libopus = require('libopus.js');
+
+var MUMBLE_SAMPLE_RATE = 48000;

node_modules/mumble-client-codecs-node/lib/decoder-stream.js

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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 _nodeOpus = require('node-opus');
+
+var _stream = require('stream');
+
+var _toArraybuffer = require('to-arraybuffer');
+
+var _toArraybuffer2 = _interopRequireDefault(_toArraybuffer);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(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; }
+
+function _inherits(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 DecoderStream = function (_Transform) {
+  _inherits(DecoderStream, _Transform);
+
+  function DecoderStream() {
+    _classCallCheck(this, DecoderStream);
+
+    return _possibleConstructorReturn(this, (DecoderStream.__proto__ || Object.getPrototypeOf(DecoderStream)).call(this, { objectMode: true }));
+  }
+
+  _createClass(DecoderStream, [{
+    key: '_transform',
+    value: function _transform(chunk, encoding, callback) {
+      if (chunk.codec === 'Opus') {
+        if (!this._opus) {
+          this._opus = new _nodeOpus.OpusEncoder(48000, 1);
+        }
+        callback(null, {
+          target: chunk.target,
+          pcm: int16ToFloat32(this._opus.decode(chunk.frame)),
+          numberOfChannels: 1,
+          position: chunk.position
+        });
+      } else {
+        callback();
+      }
+    }
+  }]);
+
+  return DecoderStream;
+}(_stream.Transform);
+
+function int16ToFloat32(raw) {
+  var asInt16 = new Int16Array((0, _toArraybuffer2.default)(raw));
+  var len = asInt16.length;
+  var asFloat32 = new Float32Array(len);
+  for (var i = 0; i < len; i++) {
+    var val = asInt16[i];
+    val = val < 0 ? val / 32768 : val / 32767;
+    asFloat32[i] = Math.max(-1, Math.min(1, val));
+  }
+  return asFloat32;
+}
+
+exports.default = DecoderStream;

node_modules/mumble-client-codecs-node/lib/encode-worker.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (self) {
+  var opusEncoder;
+  self.addEventListener('message', function (e) {
+    var data = e.data;
+    if (data.action === 'reset') {
+      if (opusEncoder) {
+        opusEncoder.destroy();
+        opusEncoder = null;
+      }
+    } else if (data.action === 'encodeOpus') {
+      if (!opusEncoder) {
+        opusEncoder = new _libopus.Encoder({
+          unsafe: true,
+          channels: data.numberOfChannels,
+          rate: MUMBLE_SAMPLE_RATE
+        });
+      }
+      var encoded = opusEncoder.encode(new Float32Array(data.buffer));
+      var buffer = (0, _toArraybuffer2.default)(encoded);
+      self.postMessage({
+        target: data.target,
+        buffer: buffer,
+        position: data.position
+      }, [buffer]);
+    }
+  });
+};
+
+var _libopus = require('libopus.js');
+
+var _toArraybuffer = require('to-arraybuffer');
+
+var _toArraybuffer2 = _interopRequireDefault(_toArraybuffer);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var MUMBLE_SAMPLE_RATE = 48000;

node_modules/mumble-client-codecs-node/lib/encoder-stream.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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 _stream = require('stream');
+
+var _reusePool = require('reuse-pool');
+
+var _reusePool2 = _interopRequireDefault(_reusePool);
+
+var _webworkifyNode = require('./webworkify-node');
+
+var _webworkifyNode2 = _interopRequireDefault(_webworkifyNode);
+
+var _encodeWorker = require('./encode-worker');
+
+var _encodeWorker2 = _interopRequireDefault(_encodeWorker);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(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; }
+
+function _inherits(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 pool = (0, _reusePool2.default)(function () {
+  return (0, _webworkifyNode2.default)(_encodeWorker2.default);
+});
+// Prepare first worker
+pool.recycle(pool.get());
+
+var EncoderStream = function (_Transform) {
+  _inherits(EncoderStream, _Transform);
+
+  function EncoderStream(codec) {
+    _classCallCheck(this, EncoderStream);
+
+    var _this = _possibleConstructorReturn(this, (EncoderStream.__proto__ || Object.getPrototypeOf(EncoderStream)).call(this, { objectMode: true }));
+
+    _this._codec = codec;
+
+    _this._worker = pool.get();
+    _this._worker.onmessage = function (msg) {
+      if (_this._worker.objectURL) {
+        // The object URL can now be revoked as the worker has been loaded
+        window.URL.revokeObjectURL(_this._worker.objectURL);
+        _this._worker.objectURL = null;
+      }
+      _this._onMessage(msg.data);
+    };
+    return _this;
+  }
+
+  _createClass(EncoderStream, [{
+    key: '_onMessage',
+    value: function _onMessage(data) {
+      this.push({
+        target: data.target,
+        codec: this._codec,
+        frame: Buffer.from(data.buffer, data.byteOffset, data.byteLength),
+        position: data.position
+      });
+    }
+  }, {
+    key: '_transform',
+    value: function _transform(chunk, encoding, callback) {
+      var buffer = chunk.pcm.slice().buffer;
+      this._worker.postMessage({
+        action: 'encode' + this._codec,
+        target: chunk.target,
+        buffer: buffer,
+        numberOfChannels: chunk.numberOfChannels,
+        position: chunk.position
+      }, [buffer]);
+      callback();
+    }
+  }, {
+    key: '_flush',
+    value: function _flush(callback) {
+      this._cleanup();
+      callback();
+    }
+  }, {
+    key: '_cleanup',
+    value: function _cleanup() {
+      this._worker.postMessage({ action: 'reset' });
+      pool.recycle(this._worker);
+    }
+  }]);
+
+  return EncoderStream;
+}(_stream.Transform);
+
+exports.default = EncoderStream;

node_modules/mumble-client-codecs-node/lib/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.opus = exports.celt = undefined;
+exports.getDuration = getDuration;
+exports.createDecoderStream = createDecoderStream;
+exports.createEncoderStream = createEncoderStream;
+
+var _nodeOpus = require('node-opus');
+
+var _decoderStream = require('./decoder-stream');
+
+var _decoderStream2 = _interopRequireDefault(_decoderStream);
+
+var _opusEncoderStream = require('./opus-encoder-stream');
+
+var _opusEncoderStream2 = _interopRequireDefault(_opusEncoderStream);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var celt = exports.celt = [];
+var opus = exports.opus = true;
+
+function getDuration(codec, buffer) {
+  if (codec === 'Opus') {
+    // node-opus doesn't expose the relevant libopus function
+    return 10;
+  } else {
+    return 1;
+  }
+}
+
+function createDecoderStream(user) {
+  return new _decoderStream2.default();
+}
+
+function createEncoderStream(codec) {
+  if (codec === 'Opus') {
+    return new _opusEncoderStream2.default(codec);
+  }
+}

node_modules/mumble-client-codecs-node/lib/opus-encoder-stream.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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 _nodeOpus = require('node-opus');
+
+var _stream = require('stream');
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(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; }
+
+function _inherits(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 OpusEncoderStream = function (_Transform) {
+  _inherits(OpusEncoderStream, _Transform);
+
+  function OpusEncoderStream() {
+    _classCallCheck(this, OpusEncoderStream);
+
+    return _possibleConstructorReturn(this, (OpusEncoderStream.__proto__ || Object.getPrototypeOf(OpusEncoderStream)).call(this, { objectMode: true }));
+  }
+
+  _createClass(OpusEncoderStream, [{
+    key: '_transform',
+    value: function _transform(chunk, encoding, callback) {
+      if (!this._opus) {
+        this._opus = new _nodeOpus.OpusEncoder(48000, chunk.numberOfChannels);
+      }
+
+      callback(null, {
+        target: chunk.target,
+        codec: 'Opus',
+        frame: this._opus.encode(Buffer.from(float32ToInt16(chunk.pcm).buffer)),
+        position: chunk.position
+      });
+    }
+  }]);
+
+  return OpusEncoderStream;
+}(_stream.Transform);
+
+function float32ToInt16(asFloat32) {
+  var len = asFloat32.length;
+  var asInt16 = new Int16Array(len);
+  for (var i = 0; i < len; i++) {
+    var val = asFloat32[i];
+    val = val < 0 ? val * 32768 : val * 32767;
+    asInt16[i] = Math.max(-32768, Math.min(32767, val));
+  }
+  return asInt16;
+}
+
+exports.default = OpusEncoderStream;

node_modules/mumble-client-codecs-node/lib/webworkify-node.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (workerFactory) {
+  var worker = new _events.EventEmitter();
+  worker.addEventListener = worker.on;
+  workerFactory(worker);
+  var client = {
+    onmessage: function onmessage() {},
+    postMessage: function postMessage(msg) {
+      process.nextTick(function () {
+        return worker.emit('message', { data: msg });
+      });
+    }
+  };
+  worker.postMessage = function (msg) {
+    process.nextTick(function () {
+      return client.onmessage({ data: msg });
+    });
+  };
+  return client;
+};
+
+var _events = require('events');