Simulator first commit

node_modules/mumble-client-codecs-node/README.md

@@ -0,0 +1,23 @@
+# mumble-client-codecs-node
+
+This module provides the [Opus codec] for the [mumble-client] module for use with nodejs.
+Neither CELT nor Speex are supported at this time.
+When native libraries are unacceptable (e.g. in a browser), consider using [mumble-client-codecs-browser] instead.
+
+### Usage
+
+```javascript
+var NodeCodecs = require('mumble-client-codecs-node')
+
+var client = new MumbleClient({
+  username: 'Test',
+  codecs: NodeCodecs
+})
+```
+
+### License
+MIT
+
+[Opus codec]: https://github.com/Rantanen/node-opus
+[mumble-client]: https://github.com/johni0702/mumble-client
+[mumble-client-codecs-browser]: https://github.com/johni0702/mumble-client-codecs-browser

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

@@ -0,0 +1,3 @@
+module.exports = require('./lib/index.js')
+// Make exports available as default import for ES6
+module.exports.default = module.exports

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');

node_modules/mumble-client-codecs-node/package.json

@@ -0,0 +1,66 @@
+{
+  "_from": "mumble-client-codecs-node@0.0.1",
+  "_id": "mumble-client-codecs-node@0.0.1",
+  "_inBundle": false,
+  "_integrity": "sha1-MW85GVtvgqHvFQ0Pn5tIX6XrZmQ=",
+  "_location": "/mumble-client-codecs-node",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "mumble-client-codecs-node@0.0.1",
+    "name": "mumble-client-codecs-node",
+    "escapedName": "mumble-client-codecs-node",
+    "rawSpec": "0.0.1",
+    "saveSpec": null,
+    "fetchSpec": "0.0.1"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/mumble-client-codecs-node/-/mumble-client-codecs-node-0.0.1.tgz",
+  "_shasum": "316f39195b6f82a1ef150d0f9f9b485fa5eb6664",
+  "_spec": "mumble-client-codecs-node@0.0.1",
+  "_where": "/home/sergiu/linx-audio-simulator",
+  "author": {
+    "name": "Jonas Herzig",
+    "email": "me@johni0702.de"
+  },
+  "bugs": {
+    "url": "https://github.com/johni0702/mumble-client-codecs-node/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "node-opus": "^0.2.6",
+    "to-arraybuffer": "^1.0.1"
+  },
+  "deprecated": false,
+  "description": "Mumble protocol client library - native codecs",
+  "devDependencies": {
+    "babel-cli": "^6.14.0",
+    "babel-preset-es2015": "^6.14.0",
+    "chai": "^3.5.0",
+    "mocha": "^3.0.2",
+    "mocha-standard": "^1.0.0",
+    "standard": "^8.0.0"
+  },
+  "files": [
+    "index.js",
+    "lib"
+  ],
+  "homepage": "https://github.com/johni0702/mumble-client-codecs-node#readme",
+  "license": "MIT",
+  "main": "index.js",
+  "name": "mumble-client-codecs-node",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johni0702/mumble-client-codecs-node.git"
+  },
+  "scripts": {
+    "compile": "babel -d lib/ src/",
+    "mocha": "mocha --compilers js:babel-core/register",
+    "prepublish": "npm run compile",
+    "test": "npm run compile && npm run mocha"
+  },
+  "version": "0.0.1"
+}