@cloud-app-dev/vidc 4.0.20 → 4.0.22

package/es/recorder/index.js

@@ -0,0 +1,992 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return e; }; var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function (t, e, r) { t[e] = r.value; }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag"; function define(t, e, r) { return Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }), t[e]; } try { define({}, ""); } catch (t) { define = function define(t, e, r) { return t[e] = r; }; } function wrap(t, e, r, n) { var i = e && e.prototype instanceof Generator ? e : Generator, a = Object.create(i.prototype), c = new Context(n || []); return o(a, "_invoke", { value: makeInvokeMethod(t, r, c) }), a; } function tryCatch(t, e, r) { try { return { type: "normal", arg: t.call(e, r) }; } catch (t) { return { type: "throw", arg: t }; } } e.wrap = wrap; var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var p = {}; define(p, a, function () { return this; }); var d = Object.getPrototypeOf, v = d && d(d(values([]))); v && v !== r && n.call(v, a) && (p = v); var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p); function defineIteratorMethods(t) { ["next", "throw", "return"].forEach(function (e) { define(t, e, function (t) { return this._invoke(e, t); }); }); } function AsyncIterator(t, e) { function invoke(r, o, i, a) { var c = tryCatch(t[r], t, o); if ("throw" !== c.type) { var u = c.arg, h = u.value; return h && "object" == _typeof(h) && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) { invoke("next", t, i, a); }, function (t) { invoke("throw", t, i, a); }) : e.resolve(h).then(function (t) { u.value = t, i(u); }, function (t) { return invoke("throw", t, i, a); }); } a(c.arg); } var r; o(this, "_invoke", { value: function value(t, n) { function callInvokeWithMethodAndArg() { return new e(function (e, r) { invoke(t, n, e, r); }); } return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(e, r, n) { var o = h; return function (i, a) { if (o === f) throw new Error("Generator is already running"); if (o === s) { if ("throw" === i) throw a; return { value: t, done: !0 }; } for (n.method = i, n.arg = a;;) { var c = n.delegate; if (c) { var u = maybeInvokeDelegate(c, n); if (u) { if (u === y) continue; return u; } } if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) { if (o === h) throw o = s, n.arg; n.dispatchException(n.arg); } else "return" === n.method && n.abrupt("return", n.arg); o = f; var p = tryCatch(e, r, n); if ("normal" === p.type) { if (o = n.done ? s : l, p.arg === y) continue; return { value: p.arg, done: n.done }; } "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg); } }; } function maybeInvokeDelegate(e, r) { var n = r.method, o = e.iterator[n]; if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y; var i = tryCatch(o, e.iterator, r.arg); if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y; var a = i.arg; return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y); } function pushTryEntry(t) { var e = { tryLoc: t[0] }; 1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e); } function resetTryEntry(t) { var e = t.completion || {}; e.type = "normal", delete e.arg, t.completion = e; } function Context(t) { this.tryEntries = [{ tryLoc: "root" }], t.forEach(pushTryEntry, this), this.reset(!0); } function values(e) { if (e || "" === e) { var r = e[a]; if (r) return r.call(e); if ("function" == typeof e.next) return e; if (!isNaN(e.length)) { var o = -1, i = function next() { for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next; return next.value = t, next.done = !0, next; }; return i.next = i; } } throw new TypeError(_typeof(e) + " is not iterable"); } return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), o(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) { var e = "function" == typeof t && t.constructor; return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name)); }, e.mark = function (t) { return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t; }, e.awrap = function (t) { return { __await: t }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () { return this; }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) { void 0 === i && (i = Promise); var a = new AsyncIterator(wrap(t, r, n, o), i); return e.isGeneratorFunction(r) ? a : a.next().then(function (t) { return t.done ? t.value : a.next(); }); }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () { return this; }), define(g, "toString", function () { return "[object Generator]"; }), e.keys = function (t) { var e = Object(t), r = []; for (var n in e) r.push(n); return r.reverse(), function next() { for (; r.length;) { var t = r.pop(); if (t in e) return next.value = t, next.done = !1, next; } return next.done = !0, next; }; }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e) { if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t); }, stop: function stop() { this.done = !0; var t = this.tryEntries[0].completion; if ("throw" === t.type) throw t.arg; return this.rval; }, dispatchException: function dispatchException(e) { if (this.done) throw e; var r = this; function handle(n, o) { return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o; } for (var o = this.tryEntries.length - 1; o >= 0; --o) { var i = this.tryEntries[o], a = i.completion; if ("root" === i.tryLoc) return handle("end"); if (i.tryLoc <= this.prev) { var c = n.call(i, "catchLoc"), u = n.call(i, "finallyLoc"); if (c && u) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } else if (c) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); } else { if (!u) throw new Error("try statement without catch or finally"); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } } } }, abrupt: function abrupt(t, e) { for (var r = this.tryEntries.length - 1; r >= 0; --r) { var o = this.tryEntries[r]; if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) { var i = o; break; } } i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null); var a = i ? i.completion : {}; return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a); }, complete: function complete(t, e) { if ("throw" === t.type) throw t.arg; return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y; }, finish: function finish(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y; } }, catch: function _catch(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.tryLoc === t) { var n = r.completion; if ("throw" === n.type) { var o = n.arg; resetTryEntry(r); } return o; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(e, r, n) { return this.delegate = { iterator: values(e), resultName: r, nextLoc: n }, "next" === this.method && (this.arg = t), y; } }, e; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+// 构造函数参数格式
+
+/**
+ * 在data中的offset位置开始写入str字符串
+ * @param {TypedArrays} data    二进制数据
+ * @param {Number}      offset  偏移量
+ * @param {String}      str     字符串
+ */
+function writeString(data, offset, str) {
+  for (var i = 0; i < str.length; i++) {
+    data.setUint8(offset + i, str.charCodeAt(i));
+  }
+}
+function concatenate() {
+  var totalLen = 0;
+  for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
+    arrays[_key] = arguments[_key];
+  }
+  for (var _i = 0, _arrays = arrays; _i < _arrays.length; _i++) {
+    var arr = _arrays[_i];
+    totalLen += arr.byteLength;
+  }
+  var res = new Uint8Array(totalLen);
+  var offset = 0;
+  for (var _i2 = 0, _arrays2 = arrays; _i2 < _arrays2.length; _i2++) {
+    var _arr = _arrays2[_i2];
+    var uint8Arr = new Uint8Array(_arr);
+    res.set(uint8Arr, offset);
+    offset += _arr.byteLength;
+  }
+  return res.buffer;
+}
+var Recorder = /*#__PURE__*/function () {
+  /**
+   * @param {Object} options 包含以下三个参数：
+   * sampleBits，采样位数，一般8,16，默认16
+   * sampleRate，采样率，一般 11025、16000、22050、24000、44100、48000，默认为浏览器自带的采样率
+   * numChannels，声道，1或2
+   */
+  function Recorder() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, Recorder);
+    _defineProperty(this, "isrecording", false);
+    // 是否正在录音
+    _defineProperty(this, "isplaying", false);
+    // 是否正在播放
+    _defineProperty(this, "ispause", false);
+    // 是否是暂停
+    _defineProperty(this, "context", void 0);
+    _defineProperty(this, "config", void 0);
+    // 配置
+    _defineProperty(this, "size", 0);
+    // 录音文件总长度
+    _defineProperty(this, "lBuffer", []);
+    // pcm音频数据搜集器(左声道)
+    _defineProperty(this, "rBuffer", []);
+    // pcm音频数据搜集器(右声道)
+    _defineProperty(this, "PCM", void 0);
+    // 最终的PCM数据缓存，避免多次encode
+    _defineProperty(this, "tempPCM", []);
+    // 边录边转时临时存放pcm的
+    _defineProperty(this, "audioInput", void 0);
+    _defineProperty(this, "inputSampleRate", void 0);
+    // 输入采样率
+    _defineProperty(this, "source", void 0);
+    // 音频输入
+    _defineProperty(this, "recorder", void 0);
+    _defineProperty(this, "outputSampleRate", 16000);
+    // 输出采样率
+    _defineProperty(this, "oututSampleBits", 16);
+    // 输出采样位数
+    _defineProperty(this, "analyser", void 0);
+    _defineProperty(this, "littleEdian", void 0);
+    // 是否是小端字节序
+    _defineProperty(this, "prevDomainData", void 0);
+    // 存放前一次图形化的数据
+    _defineProperty(this, "playStamp", 0);
+    // 播放录音时 AudioContext 记录的时间戳
+    _defineProperty(this, "playTime", 0);
+    // 记录录音播放时长
+    _defineProperty(this, "totalPlayTime", 0);
+    // 音频播放总长度
+    _defineProperty(this, "offset", 0);
+    // 边录边转，记录外部的获取偏移位置
+    _defineProperty(this, "stream", void 0);
+    // 流
+    _defineProperty(this, "fileSize", 0);
+    // 录音大小，byte为单位
+    _defineProperty(this, "duration", 0);
+    // 录音时长
+    _defineProperty(this, "onprogress", void 0);
+    var sampleBits = options.sampleBits ? options.sampleBits : 16;
+    var sampleRate = options.sampleRate ? options.sampleRate : 16000;
+    var numChannels = options.numChannels ? options.numChannels : 1;
+
+    // 临时audioContext，为了获取输入采样率的
+    var context = new AudioContext();
+    this.inputSampleRate = context.sampleRate; // 获取当前输入的采样率
+    // 配置config，检查值是否有问题
+    this.config = {
+      // 采样数位 8, 16
+      sampleBits: ~[8, 16].indexOf(sampleBits) ? sampleBits : 16,
+      // 采样率
+      sampleRate: ~[8000, 11025, 16000, 22050, 24000, 44100, 48000].indexOf(sampleRate) ? sampleRate : this.inputSampleRate,
+      // 声道数，1或2
+      numChannels: ~[1, 2].indexOf(numChannels) ? numChannels : 1,
+      // 是否需要边录边转，默认关闭，后期使用web worker
+      compiling: !!options.compiling || false
+    };
+    // 设置采样的参数
+    this.outputSampleRate = this.config.sampleRate; // 输出采样率
+    this.oututSampleBits = this.config.sampleBits; // 输出采样数位 8, 16
+    // 判断端字节序
+    this.littleEdian = function () {
+      var buffer = new ArrayBuffer(2);
+      new DataView(buffer).setInt16(0, 256, true);
+      return new Int16Array(buffer)[0] === 256;
+    }();
+  }
+
+  /**
+   * 初始化录音实例
+   */
+  _createClass(Recorder, [{
+    key: "initRecorder",
+    value: function initRecorder() {
+      var _this = this;
+      if (this.context) {
+        // 关闭先前的录音实例，因为前次的实例会缓存少量前次的录音数据
+        this.destroy();
+      }
+      this.context = new AudioContext();
+      this.analyser = this.context.createAnalyser(); // 录音分析节点
+      this.analyser.fftSize = 2048; // 表示存储频域的大小
+
+      // 第一个参数表示收集采样的大小，采集完这么多后会触发 onaudioprocess 接口一次，该值一般为1024,2048,4096等，一般就设置为4096
+      // 第二，三个参数分别是输入的声道数和输出的声道数，保持一致即可。
+      this.recorder = this.context.createScriptProcessor(4096, this.config.numChannels, this.config.numChannels);
+
+      // 音频采集
+      this.recorder.onaudioprocess = function (e) {
+        var _this$onprogress;
+        if (!_this.isrecording || _this.ispause) {
+          // 不在录音时不需要处理，FF 在停止录音后，仍会触发 audioprocess 事件
+          return;
+        }
+        // 左声道数据
+        // getChannelData返回Float32Array类型的pcm数据
+        var lData = e.inputBuffer.getChannelData(0),
+          rData = null,
+          vol = 0; // 音量百分比
+
+        _this.lBuffer.push(new Float32Array(lData));
+        _this.size += lData.length;
+
+        // 判断是否有右声道数据
+        if (2 === _this.config.numChannels) {
+          rData = e.inputBuffer.getChannelData(1);
+          _this.rBuffer.push(new Float32Array(rData));
+          _this.size += rData.length;
+        }
+
+        // 边录边转处理
+        if (_this.config.compiling) {
+          var pcm = _this.transformIntoPCM(lData, rData);
+          _this.tempPCM.push(pcm);
+          // 计算录音大小
+          _this.fileSize = pcm.byteLength * _this.tempPCM.length;
+        } else {
+          // 计算录音大小
+          _this.fileSize = Math.floor(_this.size / Math.max(_this.inputSampleRate / _this.outputSampleRate, 1)) * (_this.oututSampleBits / 8);
+        }
+        // 为何此处计算大小需要分开计算。原因是先录后转时，是将所有数据一起处理，边录边转是单个 4096 处理，
+        // 有小数位的偏差。
+
+        // 计算音量百分比
+        vol = Math.max.apply(Math, lData) * 100;
+        // 统计录音时长
+        _this.duration += 4096 / _this.inputSampleRate;
+        // 录音时长回调
+        // 录音时长及响度回调
+
+        (_this$onprogress = _this.onprogress) === null || _this$onprogress === void 0 || _this$onprogress.call(_this, {
+          duration: _this.duration,
+          fileSize: _this.fileSize,
+          vol: vol,
+          data: _this.tempPCM // 当前所有的pcm数据，调用者控制增量
+        });
+      };
+    }
+
+    /**
+     * 开始录音
+     *
+     * @returns {Promise<{}>}
+     * @memberof Recorder
+     */
+  }, {
+    key: "start",
+    value: (function () {
+      var _start = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var _this$context, _this$audioInput, _this$analyser, _this$recorder, _this$context2;
+        var stream;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (navigator.mediaDevices) {
+                _context.next = 2;
+                break;
+              }
+              return _context.abrupt("return", Promise.reject(new Error('浏览器不支持 navigator.mediaDevices !')));
+            case 2:
+              if (!this.isrecording) {
+                _context.next = 4;
+                break;
+              }
+              return _context.abrupt("return", Promise.resolve());
+            case 4:
+              // 清空数据
+              this.clear();
+              this.initRecorder();
+              this.isrecording = true;
+              _context.next = 9;
+              return navigator.mediaDevices.getUserMedia({
+                audio: true
+              });
+            case 9:
+              stream = _context.sent;
+              // audioInput表示音频源节点
+              // stream是通过navigator.getUserMedia获取的外部（如麦克风）stream音频输出，对于这就是输入
+              this.audioInput = (_this$context = this.context) === null || _this$context === void 0 ? void 0 : _this$context.createMediaStreamSource(stream);
+              this.stream = stream;
+              // audioInput 为声音源，连接到处理节点 recorder
+              (_this$audioInput = this.audioInput) === null || _this$audioInput === void 0 || _this$audioInput.connect(this.analyser);
+              (_this$analyser = this.analyser) === null || _this$analyser === void 0 || _this$analyser.connect(this.recorder);
+              // 处理节点 recorder 连接到扬声器
+              (_this$recorder = this.recorder) === null || _this$recorder === void 0 || _this$recorder.connect((_this$context2 = this.context) === null || _this$context2 === void 0 ? void 0 : _this$context2.destination);
+            case 15:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function start() {
+        return _start.apply(this, arguments);
+      }
+      return start;
+    }()
+    /**
+     * 暂停录音
+     *
+     * @memberof Recorder
+     */
+    )
+  }, {
+    key: "pause",
+    value: function pause() {
+      if (this.isrecording && !this.ispause) {
+        this.ispause = true;
+      }
+    }
+
+    /**
+     * 继续录音
+     *
+     * @memberof Recorder
+     */
+  }, {
+    key: "resume",
+    value: function resume() {
+      if (this.isrecording && this.ispause) {
+        this.ispause = false;
+      }
+    }
+
+    /**
+     * 停止录音
+     *
+     * @memberof Recorder
+     */
+  }, {
+    key: "stop",
+    value: function stop() {
+      var _this$audioInput2, _this$recorder2;
+      this.isrecording = false;
+      (_this$audioInput2 = this.audioInput) === null || _this$audioInput2 === void 0 || _this$audioInput2.disconnect();
+      (_this$recorder2 = this.recorder) === null || _this$recorder2 === void 0 || _this$recorder2.disconnect();
+    }
+
+    /**
+     * 播放录音
+     *
+     * @memberof Recorder
+     */
+  }, {
+    key: "play",
+    value: function play() {
+      var _this$source;
+      this.stop();
+      // 关闭前一次音频播放
+      (_this$source = this.source) === null || _this$source === void 0 || _this$source.stop();
+      this.isplaying = true;
+      this.playTime = 0;
+
+      // 记录开始播放的时间
+      this.playAudioData();
+    }
+
+    /**
+     * 获取音频文件已经播放了的时间
+     *
+     * @returns {number}
+     * @memberof Recorder
+     */
+  }, {
+    key: "getPlayTime",
+    value: function getPlayTime() {
+      var _now = 0;
+      if (this.isplaying) {
+        var _this$context$current, _this$context3;
+        // 播放中，使用预留时间 + 偏差时间
+        _now = ((_this$context$current = (_this$context3 = this.context) === null || _this$context3 === void 0 ? void 0 : _this$context3.currentTime) !== null && _this$context$current !== void 0 ? _this$context$current : 0) - this.playStamp + this.playTime;
+      } else {
+        _now = this.playTime;
+      }
+      if (_now >= this.totalPlayTime) {
+        _now = this.totalPlayTime;
+      }
+      return _now;
+    }
+
+    /**
+     * 暂停播放录音
+     *
+     * @memberof Recorder
+     */
+  }, {
+    key: "pausePlay",
+    value: function pausePlay() {
+      var _this$source2, _this$context$current2, _this$context4;
+      if (this.isrecording || !this.isplaying) {
+        // 正在录音或没有播放，暂停无效
+        return;
+      }
+      (_this$source2 = this.source) === null || _this$source2 === void 0 || _this$source2.disconnect();
+      // 多次暂停需要累加
+      this.playTime += ((_this$context$current2 = (_this$context4 = this.context) === null || _this$context4 === void 0 ? void 0 : _this$context4.currentTime) !== null && _this$context$current2 !== void 0 ? _this$context$current2 : 0) - this.playStamp;
+      this.isplaying = false;
+    }
+
+    /**
+     * 恢复播放录音
+     *
+     * @memberof Recorder
+     */
+  }, {
+    key: "resumePlay",
+    value: function resumePlay() {
+      if (this.isrecording || this.isplaying || 0 === this.playTime) {
+        // 正在录音或已经播放或没开始播放，恢复无效
+        return;
+      }
+      this.isplaying = true;
+      this.playAudioData();
+    }
+
+    /**
+     * 停止播放
+     *
+     * @memberof Recorder
+     */
+  }, {
+    key: "stopPlay",
+    value: function stopPlay() {
+      var _this$source3;
+      if (this.isrecording) {
+        // 正在录音，停止录音播放无效
+        return;
+      }
+      this.playTime = 0;
+      this.isplaying = false;
+      (_this$source3 = this.source) === null || _this$source3 === void 0 || _this$source3.stop();
+    }
+
+    /**
+     * 获取当前已经录音的PCM音频数据
+     *
+     * @returns[DataView]
+     * @memberof Recorder
+     */
+  }, {
+    key: "getWholeData",
+    value: function getWholeData() {
+      return this.tempPCM;
+    }
+
+    /**
+     * 获取余下的新数据，不包括 getNextData 前一次获取的数据
+     *
+     * @returns [DataView]
+     * @memberof Recorder
+     */
+  }, {
+    key: "getNextData",
+    value: function getNextData() {
+      var length = this.tempPCM.length,
+        data = this.tempPCM.slice(this.offset);
+      this.offset = length;
+      if (data.length === 0) {
+        return undefined;
+      }
+      return concatenate.apply(void 0, _toConsumableArray(data.map(function (v) {
+        return v.buffer;
+      })));
+    }
+
+    /**
+     * 利用 decodeAudioData播放录音数据，每次播放都需创建，因为buffersource只能被使用一次
+     *
+     * @private
+     * @memberof Recorder
+     */
+  }, {
+    key: "playAudioData",
+    value: function playAudioData() {
+      var _this$context5,
+        _this2 = this;
+      (_this$context5 = this.context) === null || _this$context5 === void 0 || _this$context5.decodeAudioData(this.getWAV().buffer, function (buffer) {
+        var _this2$context, _this2$analyser, _this2$context2, _this2$context3;
+        _this2.source = (_this2$context = _this2.context) === null || _this2$context === void 0 ? void 0 : _this2$context.createBufferSource();
+
+        // 设置数据
+        _this2.source.buffer = buffer;
+        _this2.totalPlayTime = _this2.source.buffer.duration;
+        // connect到分析器，还是用录音的，因为播放时不能录音的
+        _this2.source.connect(_this2.analyser);
+        (_this2$analyser = _this2.analyser) === null || _this2$analyser === void 0 || _this2$analyser.connect((_this2$context2 = _this2.context) === null || _this2$context2 === void 0 ? void 0 : _this2$context2.destination);
+        _this2.source.start(0, _this2.playTime);
+
+        // 记录当前的时间戳，以备暂停时使用
+        _this2.playStamp = (_this2$context3 = _this2.context) === null || _this2$context3 === void 0 ? void 0 : _this2$context3.currentTime;
+      }, function (e) {
+        Recorder.throwError(e);
+      });
+    }
+
+    /**
+     * 获取当前录音的波形数据，
+     * 调取频率由外部控制。
+     *
+     * @memberof Recorder
+     */
+  }, {
+    key: "getRecordAnalyseData",
+    value: function getRecordAnalyseData() {
+      var _this$analyser2, _this$analyser3;
+      if (this.ispause) {
+        // 暂停时不需要发送录音的数据，处理FF下暂停仍就获取录音数据的问题
+        // 为防止暂停后，画面空白，故返回先前的数据
+        return this.prevDomainData;
+      }
+      var dataArray = new Uint8Array((_this$analyser2 = this.analyser) === null || _this$analyser2 === void 0 ? void 0 : _this$analyser2.frequencyBinCount);
+      // 将数据拷贝到dataArray中。
+      (_this$analyser3 = this.analyser) === null || _this$analyser3 === void 0 || _this$analyser3.getByteTimeDomainData(dataArray);
+      return this.prevDomainData = dataArray;
+    }
+
+    /**
+     * 获取录音播放时的波形数据，
+     *
+     * @memberof Recorder
+     */
+  }, {
+    key: "getPlayAnalyseData",
+    value: function getPlayAnalyseData() {
+      // 现在录音和播放不允许同时进行，所有复用的录音的analyser节点。
+      return this.getRecordAnalyseData();
+    }
+
+    /**
+     * 获取PCM编码的二进制数据(dataview)
+     *
+     * @returns {dataview}  PCM二进制数据
+     * @memberof Recorder
+     */
+  }, {
+    key: "getPCM",
+    value: function getPCM() {
+      if (this.tempPCM.length) {
+        // 优先使用边录边存下的
+        // 将存下的 DataView 数据合并了
+        var buffer = new ArrayBuffer(this.tempPCM.length * this.tempPCM[0].byteLength),
+          pcm = new DataView(buffer),
+          offset = 0;
+
+        // 遍历存储数据
+        this.tempPCM.forEach(function (block) {
+          for (var i = 0, len = block.byteLength; i < len; ++i) {
+            pcm.setInt8(offset, block.getInt8(i));
+            offset++;
+          }
+        });
+        // 最终的PCM数据已经有了，temp不需要了
+        this.PCM = pcm;
+        this.tempPCM = [];
+      }
+      if (this.PCM) {
+        // 给缓存
+        return this.PCM;
+      }
+      // 二维转一维
+      var data = this.flat();
+      // 压缩或扩展
+      data = Recorder.compress(data, this.inputSampleRate, this.outputSampleRate);
+      // 按采样位数重新编码
+      this.PCM = Recorder.encodePCM(data, this.oututSampleBits, this.littleEdian);
+      return this.PCM;
+    }
+
+    /**
+     * 获取PCM格式的blob数据
+     *
+     * @returns { blob }  PCM格式的blob数据
+     * @memberof Recorder
+     */
+  }, {
+    key: "getPCMBlob",
+    value: function getPCMBlob() {
+      // 先停止
+      this.stop();
+      return new Blob([this.getPCM()]);
+    }
+
+    /**
+     * 下载录音pcm数据
+     *
+     * @param {string} [name='recorder']    重命名的名字
+     * @memberof Recorder
+     */
+  }, {
+    key: "downloadPCM",
+    value: function downloadPCM() {
+      var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'recorder';
+      var pcmBlob = this.getPCMBlob();
+      this.download(pcmBlob, name, 'pcm');
+    }
+
+    /**
+     * 获取WAV编码的二进制数据(dataview)
+     *
+     * @returns {dataview}  WAV编码的二进制数据
+     * @memberof Recorder
+     */
+  }, {
+    key: "getWAV",
+    value: function getWAV() {
+      var pcmTemp = this.getPCM(),
+        wavTemp = Recorder.encodeWAV(pcmTemp, this.inputSampleRate, this.outputSampleRate, this.config.numChannels, this.oututSampleBits, this.littleEdian);
+      return wavTemp;
+    }
+
+    /**
+     * 获取WAV音频的blob数据
+     *
+     * @returns { Blob }    wav格式blob数据
+     * @memberof Recorder
+     */
+  }, {
+    key: "getWAVBlob",
+    value: function getWAVBlob() {
+      // 先停止
+      this.stop();
+      return new Blob([this.getWAV()], {
+        type: 'audio/wav'
+      });
+    }
+
+    /**
+     * 下载录音的wav数据
+     *
+     * @param {string} [name='recorder']    重命名的名字
+     * @memberof Recorder
+     */
+  }, {
+    key: "downloadWAV",
+    value: function downloadWAV() {
+      var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'recorder';
+      var wavBlob = this.getWAVBlob();
+      this.download(wavBlob, name, 'wav');
+    }
+
+    /**
+     * 将获取到到左右声道的Float32Array数据编码转化
+     *
+     * @param {Float32Array} lData  左声道数据
+     * @param {Float32Array} rData  有声道数据
+     * @returns DataView
+     */
+  }, {
+    key: "transformIntoPCM",
+    value: function transformIntoPCM(lData, rData) {
+      var lBuffer = new Float32Array(lData);
+      var rBuffer = new Float32Array(rData);
+      var data = Recorder.compress({
+        left: lBuffer,
+        right: rBuffer
+      }, this.inputSampleRate, this.outputSampleRate);
+      return Recorder.encodePCM(data, this.oututSampleBits, this.littleEdian);
+    }
+
+    /**
+     * 销毁录音对象
+     * @memberof Recorder
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      // 结束流
+      this.stopStream();
+      return this.closeAudioContext();
+    }
+
+    /**
+     * 终止流（这可以让浏览器上正在录音的标志消失掉）
+     * @private
+     * @memberof Recorder
+     */
+  }, {
+    key: "stopStream",
+    value: function stopStream() {
+      if (this.stream && this.stream.getTracks) {
+        this.stream.getTracks().forEach(function (track) {
+          return track.stop();
+        });
+        this.stream = undefined;
+      }
+    }
+
+    /**
+     * close兼容方案
+     * 如firefox 30 等低版本浏览器没有 close方法
+     */
+  }, {
+    key: "closeAudioContext",
+    value: function closeAudioContext() {
+      if (this.context && this.context.state !== 'closed') {
+        return this.context.close();
+      } else {
+        return Promise.resolve();
+      }
+    }
+
+    /**
+     * 下载录音文件
+     * @private
+     * @param {*} blob      blob数据
+     * @param {string} name 下载的文件名
+     * @param {string} type 下载的文件后缀
+     * @memberof Recorder
+     */
+  }, {
+    key: "download",
+    value: function download(blob, name, type) {
+      try {
+        var oA = document.createElement('a');
+        oA.href = window.URL.createObjectURL(blob);
+        oA.download = name + '.' + type;
+        oA.click();
+      } catch (e) {
+        Recorder.throwError(e);
+      }
+    }
+
+    /**
+     * 清空状态，重新开始录音（变量初始化）
+     *
+     * @private
+     * @memberof Recorder
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.lBuffer.length = 0;
+      this.rBuffer.length = 0;
+      this.size = 0;
+      this.fileSize = 0;
+      this.PCM = null;
+      this.audioInput = undefined;
+      this.duration = 0;
+      this.ispause = false;
+      this.isplaying = false;
+      this.playTime = 0;
+      this.totalPlayTime = 0;
+
+      // 录音前，关闭录音播放
+      if (this.source) {
+        this.source.stop();
+        // 重新开启录制，由于新建了 AudioContext ，source需要清空，
+        // 处理iphone 上 safari 浏览器 第二次播放报错的问题。
+        this.source = undefined;
+      }
+    }
+
+    /**
+     * 将二维数组转一维
+     *
+     * @private
+     * @returns  {float32array}     音频pcm二进制数据
+     * @memberof Recorder
+     */
+  }, {
+    key: "flat",
+    value: function flat() {
+      var lData = null,
+        rData = new Float32Array(0); // 右声道默认为0
+
+      // 创建存放数据的容器
+      if (1 === this.config.numChannels) {
+        lData = new Float32Array(this.size);
+      } else {
+        lData = new Float32Array(this.size / 2);
+        rData = new Float32Array(this.size / 2);
+      }
+      // 合并
+      var offset = 0; // 偏移量计算
+
+      // 将二维数据，转成一维数据
+      // 左声道
+      for (var i = 0; i < this.lBuffer.length; i++) {
+        lData.set(this.lBuffer[i], offset);
+        offset += this.lBuffer[i].length;
+      }
+      offset = 0;
+      // 右声道
+      for (var _i3 = 0; _i3 < this.rBuffer.length; _i3++) {
+        rData.set(this.rBuffer[_i3], offset);
+        offset += this.rBuffer[_i3].length;
+      }
+      return {
+        left: lData,
+        right: rData
+      };
+    }
+
+    /**
+     * 播放外部音乐文件
+     *
+     * @param {float32array} blob    blob音频数据
+     * @memberof Recorder
+     */
+  }], [{
+    key: "playAudio",
+    value: function playAudio(blob) {
+      var oAudio = document.createElement('audio');
+      oAudio.src = window.URL.createObjectURL(blob);
+      // 播放音乐
+      oAudio.play();
+    }
+
+    /**
+     * 数据合并压缩
+     * 根据输入和输出的采样率压缩数据，
+     * 比如输入的采样率是48k的，我们需要的是（输出）的是16k的，由于48k与16k是3倍关系，
+     * 所以输入数据中每隔3取1位
+     *
+     * @static
+     * @param {float32array} data       [-1, 1]的pcm数据
+     * @param {number} inputSampleRate  输入采样率
+     * @param {number} outputSampleRate 输出采样率
+     * @returns  {float32array}         压缩处理后的二进制数据
+     * @memberof Recorder
+     */
+  }, {
+    key: "compress",
+    value: function compress(data, inputSampleRate, outputSampleRate) {
+      // 压缩，根据采样率进行压缩
+      var rate = inputSampleRate / outputSampleRate,
+        compression = Math.max(rate, 1),
+        lData = data.left,
+        rData = data.right,
+        length = Math.floor((lData.length + rData.length) / rate),
+        result = new Float32Array(length),
+        index = 0,
+        j = 0;
+
+      // 循环间隔 compression 位取一位数据
+      while (index < length) {
+        var temp = Math.floor(j);
+        result[index] = lData[temp];
+        index++;
+        if (rData.length) {
+          /*
+           * 双声道处理
+           * e.inputBuffer.getChannelData(0)得到了左声道4096个样本数据，1是右声道的数据，
+           * 此处需要组和成LRLRLR这种格式，才能正常播放，所以要处理下
+           */
+          result[index] = rData[temp];
+          index++;
+        }
+        j += compression;
+      }
+      // 返回压缩后的一维数据
+      return result;
+    }
+
+    /**
+     * 转换到我们需要的对应格式的编码
+     *
+     * @static
+     * @param {Float32Array} bytes      pcm二进制数据
+     * @param {number}  sampleBits      采样位数
+     * @param {boolean} littleEdian     是否是小端字节序
+     * @returns {dataview}              pcm二进制数据
+     * @memberof Recorder
+     */
+  }, {
+    key: "encodePCM",
+    value: function encodePCM(bytes, sampleBits) {
+      var littleEdian = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      var offset = 0,
+        dataLength = bytes.length * (sampleBits / 8),
+        buffer = new ArrayBuffer(dataLength),
+        data = new DataView(buffer);
+
+      // 写入采样数据
+      if (sampleBits === 8) {
+        for (var i = 0; i < bytes.length; i++, offset++) {
+          // 范围[-1, 1]
+          var s = Math.max(-1, Math.min(1, bytes[i]));
+          // 8位采样位划分成2^8=256份，它的范围是0-255;
+          // 对于8位的话，负数*128，正数*127，然后整体向上平移128(+128)，即可得到[0,255]范围的数据。
+          var val = s < 0 ? s * 128 : s * 127;
+          val = +val + 128;
+          data.setInt8(offset, val);
+        }
+      } else {
+        for (var _i4 = 0; _i4 < bytes.length; _i4++, offset += 2) {
+          var _s = Math.max(-1, Math.min(1, bytes[_i4]));
+          // 16位的划分的是2^16=65536份，范围是-32768到32767
+          // 因为我们收集的数据范围在[-1,1]，那么你想转换成16位的话，只需要对负数*32768,对正数*32767,即可得到范围在[-32768,32767]的数据。
+          data.setInt16(offset, _s < 0 ? _s * 0x8000 : _s * 0x7fff, littleEdian);
+        }
+      }
+      return data;
+    }
+
+    /**
+     * 编码wav，一般wav格式是在pcm文件前增加44个字节的文件头，
+     * 所以，此处只需要在pcm数据前增加下就行了。
+     *
+     * @static
+     * @param {DataView} bytes           pcm二进制数据
+     * @param {number}  inputSampleRate  输入采样率
+     * @param {number}  outputSampleRate 输出采样率
+     * @param {number}  numChannels      声道数
+     * @param {number}  oututSampleBits  输出采样位数
+     * @param {boolean} littleEdian      是否是小端字节序
+     * @returns {DataView}               wav二进制数据
+     * @memberof Recorder
+     */
+  }, {
+    key: "encodeWAV",
+    value: function encodeWAV(bytes, inputSampleRate, outputSampleRate, numChannels, oututSampleBits) {
+      var littleEdian = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;
+      var sampleRate = outputSampleRate > inputSampleRate ? inputSampleRate : outputSampleRate,
+        // 输出采样率较大时，仍使用输入的值，
+        sampleBits = oututSampleBits,
+        buffer = new ArrayBuffer(44 + bytes.byteLength),
+        data = new DataView(buffer),
+        channelCount = numChannels,
+        // 声道
+        offset = 0;
+
+      // 资源交换文件标识符
+      writeString(data, offset, 'RIFF');
+      offset += 4;
+      // 下个地址开始到文件尾总字节数,即文件大小-8
+      data.setUint32(offset, 36 + bytes.byteLength, littleEdian);
+      offset += 4;
+      // WAV文件标志
+      writeString(data, offset, 'WAVE');
+      offset += 4;
+      // 波形格式标志
+      writeString(data, offset, 'fmt ');
+      offset += 4;
+      // 过滤字节,一般为 0x10 = 16
+      data.setUint32(offset, 16, littleEdian);
+      offset += 4;
+      // 格式类别 (PCM形式采样数据)
+      data.setUint16(offset, 1, littleEdian);
+      offset += 2;
+      // 声道数
+      data.setUint16(offset, channelCount, littleEdian);
+      offset += 2;
+      // 采样率,每秒样本数,表示每个通道的播放速度
+      data.setUint32(offset, sampleRate, littleEdian);
+      offset += 4;
+      // 波形数据传输率 (每秒平均字节数) 声道数 × 采样频率 × 采样位数 / 8
+      data.setUint32(offset, channelCount * sampleRate * (sampleBits / 8), littleEdian);
+      offset += 4;
+      // 快数据调整数 采样一次占用字节数 声道数 × 采样位数 / 8
+      data.setUint16(offset, channelCount * (sampleBits / 8), littleEdian);
+      offset += 2;
+      // 采样位数
+      data.setUint16(offset, sampleBits, littleEdian);
+      offset += 2;
+      // 数据标识符
+      writeString(data, offset, 'data');
+      offset += 4;
+      // 采样数据总数,即数据总大小-44
+      data.setUint32(offset, bytes.byteLength, littleEdian);
+      offset += 4;
+
+      // 给wav头增加pcm体
+      for (var i = 0; i < bytes.byteLength;) {
+        data.setUint8(offset, bytes.getUint8(i));
+        offset++;
+        i++;
+      }
+      return data;
+    }
+
+    /**
+     * 异常处理
+     * @static
+     * @param {*} message   错误消息
+     * @memberof Recorder
+     */
+  }, {
+    key: "throwError",
+    value: function throwError(message) {
+      throw new Error(message);
+    }
+
+    /**
+     * 在没有权限的时候，让弹出获取麦克风弹窗
+     *
+     */
+  }, {
+    key: "getPermission",
+    value: (function () {
+      var _getPermission = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        var stream;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (navigator.mediaDevices) {
+                _context2.next = 2;
+                break;
+              }
+              return _context2.abrupt("return", Promise.reject(new Error('浏览器不支持 navigator.mediaDevices !')));
+            case 2:
+              _context2.next = 4;
+              return navigator.mediaDevices.getUserMedia({
+                audio: true
+              });
+            case 4:
+              stream = _context2.sent;
+              stream.getTracks().forEach(function (track) {
+                return track.stop();
+              });
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function getPermission() {
+        return _getPermission.apply(this, arguments);
+      }
+      return getPermission;
+    }())
+  }]);
+  return Recorder;
+}();
+export default Recorder;