cnhis-design-vue 3.3.1-release.4 → 3.3.1-release.5

package/es/components/audio-sdk/src/utils/recorder/recorder.js

@@ -0,0 +1,1324 @@
+var NOOP = function() {
+};
+var Recorder = function(set) {
+  return new initFn(set);
+};
+Recorder.LM = "2023-07-01 20:46";
+var RecTxt = "Recorder";
+var getUserMediaTxt = "getUserMedia";
+var srcSampleRateTxt = "srcSampleRate";
+var sampleRateTxt = "sampleRate";
+var CatchTxt = "catch";
+Recorder.IsOpen = function() {
+  var stream = Recorder.Stream;
+  if (stream) {
+    var tracks = stream.getTracks && stream.getTracks() || stream.audioTracks || [];
+    var track = tracks[0];
+    if (track) {
+      var state = track.readyState;
+      return state == "live" || state == track.LIVE;
+    }
+  }
+  return false;
+};
+Recorder.BufferSize = 4096;
+Recorder.Destroy = function() {
+  CLog(RecTxt + " Destroy");
+  Disconnect();
+  for (var k in DestroyList) {
+    DestroyList[k]();
+  }
+};
+var DestroyList = {};
+Recorder.BindDestroy = function(key, call) {
+  DestroyList[key] = call;
+};
+Recorder.Support = function() {
+  var scope = navigator.mediaDevices || {};
+  if (!scope[getUserMediaTxt]) {
+    scope = navigator;
+    scope[getUserMediaTxt] || (scope[getUserMediaTxt] = scope.webkitGetUserMedia || scope.mozGetUserMedia || scope.msGetUserMedia);
+  }
+  if (!scope[getUserMediaTxt]) {
+    return false;
+  }
+  Recorder.Scope = scope;
+  if (!Recorder.GetContext()) {
+    return false;
+  }
+  return true;
+};
+Recorder.GetContext = function(tryNew) {
+  var AC = window.AudioContext;
+  if (!AC) {
+    AC = window.webkitAudioContext;
+  }
+  if (!AC) {
+    return null;
+  }
+  var ctx = Recorder.Ctx;
+  if (!ctx || ctx.state == "closed") {
+    ctx = Recorder.Ctx = new AC();
+    Recorder.NewCtxs = Recorder.NewCtxs || [];
+    Recorder.BindDestroy("Ctx", function() {
+      var ctx2 = Recorder.Ctx;
+      if (ctx2 && ctx2.close) {
+        ctx2.close();
+        Recorder.Ctx = 0;
+      }
+      var arr = Recorder.NewCtxs;
+      Recorder.NewCtxs = [];
+      for (var i = 0; i < arr.length; i++)
+        arr[i].close();
+    });
+  }
+  if (tryNew && ctx.close) {
+    try {
+      ctx = new AC();
+      Recorder.NewCtxs.push(ctx);
+    } catch (e) {
+      CLog("GetContext tryNew\u5F02\u5E38", 1, e);
+    }
+  }
+  return ctx;
+};
+Recorder.CloseNewCtx = function(ctx) {
+  if (ctx && ctx != Recorder.Ctx) {
+    ctx.close && ctx.close();
+    var arr = Recorder.NewCtxs || [], L = arr.length;
+    for (var i = 0; i < arr.length; i++) {
+      if (arr[i] == ctx) {
+        arr.splice(i, 1);
+        break;
+      }
+    }
+    CLog("\u5269" + L + "-1=" + arr.length + "\u4E2AGetContext\u672Aclose", arr.length ? 3 : 0);
+  }
+};
+var CtxState = function(ctx) {
+  var v = ctx.state, msg = "ctx.state=" + v;
+  if (v == "suspended")
+    msg += "\uFF08\u6CE8\u610F\uFF1Actx\u4E0D\u662Frunning\u72B6\u6001\uFF0Crec.open\u548Cstart\u81F3\u5C11\u8981\u6709\u4E00\u4E2A\u5728\u7528\u6237\u64CD\u4F5C(\u89E6\u6478\u3001\u70B9\u51FB\u7B49)\u65F6\u8FDB\u884C\u8C03\u7528\uFF0C\u5426\u5219\u5C06\u5728rec.start\u65F6\u5C1D\u8BD5\u8FDB\u884Cctx.resume\uFF0C\u53EF\u80FD\u4F1A\u4EA7\u751F\u517C\u5BB9\u6027\u95EE\u9898(\u4EC5iOS)\uFF0C\u8BF7\u53C2\u9605\u6587\u6863\u4E2DrunningContext\u914D\u7F6E\uFF09";
+  return msg;
+};
+var ConnectEnableWebM = "ConnectEnableWebM";
+Recorder[ConnectEnableWebM] = true;
+var ConnectEnableWorklet = "ConnectEnableWorklet";
+Recorder[ConnectEnableWorklet] = false;
+var Connect = function(streamStore, isUserMedia) {
+  var bufferSize = streamStore.BufferSize || Recorder.BufferSize;
+  var stream = streamStore.Stream;
+  var ctx = stream._RC || stream._c || Recorder.GetContext(true);
+  stream._c = ctx;
+  var mediaConn = function(node) {
+    var media = stream._m = ctx.createMediaStreamSource(stream);
+    var ctxDest = ctx.destination, cmsdTxt = "createMediaStreamDestination";
+    if (ctx[cmsdTxt]) {
+      ctxDest = stream._d = ctx[cmsdTxt]();
+    }
+    media.connect(node);
+    node.connect(ctxDest);
+  };
+  var isWebM, isWorklet, badInt, webMTips = "";
+  var calls = stream._call;
+  var onReceive = function(float32Arr) {
+    for (var k0 in calls) {
+      var size = float32Arr.length;
+      var pcm = new Int16Array(size);
+      var sum = 0;
+      for (var j = 0; j < size; j++) {
+        var s = Math.max(-1, Math.min(1, float32Arr[j]));
+        s = s < 0 ? s * 32768 : s * 32767;
+        pcm[j] = s;
+        sum += Math.abs(s);
+      }
+      for (var k in calls) {
+        calls[k](pcm, sum);
+      }
+      return;
+    }
+  };
+  var scriptProcessor = "ScriptProcessor";
+  var audioWorklet = "audioWorklet";
+  var recAudioWorklet = RecTxt + " " + audioWorklet;
+  var RecProc = "RecProc";
+  var MediaRecorderTxt = "MediaRecorder";
+  var MRWebMPCM = MediaRecorderTxt + ".WebM.PCM";
+  var oldFn = ctx.createScriptProcessor || ctx.createJavaScriptNode;
+  var oldIsBest = "\u3002\u7531\u4E8E" + audioWorklet + "\u5185\u90E81\u79D2375\u6B21\u56DE\u8C03\uFF0C\u5728\u79FB\u52A8\u7AEF\u53EF\u80FD\u4F1A\u6709\u6027\u80FD\u95EE\u9898\u5BFC\u81F4\u56DE\u8C03\u4E22\u5931\u5F55\u97F3\u53D8\u77ED\uFF0CPC\u7AEF\u65E0\u5F71\u54CD\uFF0C\u6682\u4E0D\u5EFA\u8BAE\u5F00\u542F" + audioWorklet + "\u3002";
+  var oldScript = function() {
+    isWorklet = stream.isWorklet = false;
+    _Disconn_n(stream);
+    CLog(
+      "Connect\u91C7\u7528\u8001\u7684" + scriptProcessor + "\uFF0C" + (Recorder[ConnectEnableWorklet] ? "\u4F46\u5DF2" : "\u53EF") + "\u8BBE\u7F6E" + RecTxt + "." + ConnectEnableWorklet + "=true\u5C1D\u8BD5\u542F\u7528" + audioWorklet + webMTips + oldIsBest,
+      3
+    );
+    var process = stream._p = oldFn.call(ctx, bufferSize, 1, 1);
+    mediaConn(process);
+    process.onaudioprocess = function(e) {
+      var arr = e.inputBuffer.getChannelData(0);
+      onReceive(arr);
+    };
+  };
+  var connWorklet = function() {
+    isWebM = stream.isWebM = false;
+    _Disconn_r(stream);
+    isWorklet = stream.isWorklet = !oldFn || Recorder[ConnectEnableWorklet];
+    var AwNode = window.AudioWorkletNode;
+    if (!(isWorklet && ctx[audioWorklet] && AwNode)) {
+      oldScript();
+      return;
+    }
+    var clazzUrl = function() {
+      var xf = function(f) {
+        return f.toString().replace(/^function|DEL_/g, "").replace(/\$RA/g, recAudioWorklet);
+      };
+      var clazz = "class " + RecProc + " extends AudioWorkletProcessor{";
+      clazz += "constructor " + xf(function(option) {
+        DEL_super(option);
+        var This = this, bufferSize2 = option.processorOptions.bufferSize;
+        This.bufferSize = bufferSize2;
+        This.buffer = new Float32Array(bufferSize2 * 2);
+        This.pos = 0;
+        This.port.onmessage = function(e) {
+          if (e.data.kill) {
+            This.kill = true;
+            $C.log("$RA kill call");
+          }
+        };
+        $C.log("$RA .ctor call", option);
+      });
+      clazz += "process " + xf(function(input, b, c) {
+        var This = this, bufferSize2 = This.bufferSize;
+        var buffer = This.buffer, pos = This.pos;
+        input = (input[0] || [])[0] || [];
+        if (input.length) {
+          buffer.set(input, pos);
+          pos += input.length;
+          var len = ~~(pos / bufferSize2) * bufferSize2;
+          if (len) {
+            this.port.postMessage({ val: buffer.slice(0, len) });
+            var more = buffer.subarray(len, pos);
+            buffer = new Float32Array(bufferSize2 * 2);
+            buffer.set(more);
+            pos = more.length;
+            This.buffer = buffer;
+          }
+          This.pos = pos;
+        }
+        return !This.kill;
+      });
+      clazz += '}try{registerProcessor("' + RecProc + '", ' + RecProc + ')}catch(e){$C.error("' + recAudioWorklet + '\u6CE8\u518C\u5931\u8D25",e)}';
+      clazz = clazz.replace(/\$C\./g, "console.");
+      return "data:text/javascript;base64," + btoa(unescape(encodeURIComponent(clazz)));
+    };
+    var awNext = function() {
+      return isWorklet && stream._na;
+    };
+    var nodeAlive = stream._na = function() {
+      if (badInt !== "") {
+        clearTimeout(badInt);
+        badInt = setTimeout(function() {
+          badInt = 0;
+          if (awNext()) {
+            CLog(audioWorklet + "\u672A\u8FD4\u56DE\u4EFB\u4F55\u97F3\u9891\uFF0C\u6062\u590D\u4F7F\u7528" + scriptProcessor, 3);
+            oldFn && oldScript();
+          }
+        }, 500);
+      }
+    };
+    var createNode = function() {
+      if (!awNext())
+        return;
+      var node = stream._n = new AwNode(ctx, RecProc, {
+        processorOptions: { bufferSize }
+      });
+      mediaConn(node);
+      node.port.onmessage = function(e) {
+        if (badInt) {
+          clearTimeout(badInt);
+          badInt = "";
+        }
+        if (awNext()) {
+          onReceive(e.data.val);
+        } else if (!isWorklet) {
+          CLog(audioWorklet + "\u591A\u4F59\u56DE\u8C03", 3);
+        }
+      };
+      CLog(
+        "Connect\u91C7\u7528" + audioWorklet + "\uFF0C\u8BBE\u7F6E" + RecTxt + "." + ConnectEnableWorklet + "=false\u53EF\u6062\u590D\u8001\u5F0F" + scriptProcessor + webMTips + oldIsBest,
+        3
+      );
+    };
+    ctx.resume()[calls && "finally"](function() {
+      if (!awNext())
+        return;
+      if (ctx[RecProc]) {
+        createNode();
+        return;
+      }
+      var url = clazzUrl();
+      ctx[audioWorklet].addModule(url).then(function(e) {
+        if (!awNext())
+          return;
+        ctx[RecProc] = 1;
+        createNode();
+        if (badInt) {
+          nodeAlive();
+        }
+      })[CatchTxt](function(e) {
+        CLog(audioWorklet + ".addModule\u5931\u8D25", 1, e);
+        awNext() && oldScript();
+      });
+    });
+  };
+  var connWebM = function() {
+    var MR = window[MediaRecorderTxt];
+    var onData = "ondataavailable";
+    var webmType = "audio/webm; codecs=pcm";
+    isWebM = stream.isWebM = Recorder[ConnectEnableWebM];
+    var supportMR = MR && onData in MR.prototype && MR.isTypeSupported(webmType);
+    webMTips = supportMR ? "" : "\uFF08\u6B64\u6D4F\u89C8\u5668\u4E0D\u652F\u6301" + MRWebMPCM + "\uFF09";
+    if (!isUserMedia || !isWebM || !supportMR) {
+      connWorklet();
+      return;
+    }
+    var mrNext = function() {
+      return isWebM && stream._ra;
+    };
+    stream._ra = function() {
+      if (badInt !== "") {
+        clearTimeout(badInt);
+        badInt = setTimeout(function() {
+          if (mrNext()) {
+            CLog(MediaRecorderTxt + "\u672A\u8FD4\u56DE\u4EFB\u4F55\u97F3\u9891\uFF0C\u964D\u7EA7\u4F7F\u7528" + audioWorklet, 3);
+            connWorklet();
+          }
+        }, 500);
+      }
+    };
+    var mrSet = Object.assign({ mimeType: webmType }, Recorder.ConnectWebMOptions);
+    var mr = stream._r = new MR(stream, mrSet);
+    var webmData = stream._rd = { sampleRate: ctx[sampleRateTxt] };
+    mr[onData] = function(e) {
+      var reader = new FileReader();
+      reader.onloadend = function() {
+        if (mrNext()) {
+          var f32arr = WebM_Extract(new Uint8Array(reader.result), webmData);
+          if (!f32arr)
+            return;
+          if (f32arr == -1) {
+            connWorklet();
+            return;
+          }
+          if (badInt) {
+            clearTimeout(badInt);
+            badInt = "";
+          }
+          onReceive(f32arr);
+        } else if (!isWebM) {
+          CLog(MediaRecorderTxt + "\u591A\u4F59\u56DE\u8C03", 3);
+        }
+      };
+      reader.readAsArrayBuffer(e.data);
+    };
+    mr.start(~~(bufferSize / 48));
+    CLog(
+      "Connect\u91C7\u7528" + MRWebMPCM + "\uFF0C\u8BBE\u7F6E" + RecTxt + "." + ConnectEnableWebM + "=false\u53EF\u6062\u590D\u4F7F\u7528" + audioWorklet + "\u6216\u8001\u5F0F" + scriptProcessor
+    );
+  };
+  connWebM();
+};
+var ConnAlive = function(stream) {
+  if (stream._na)
+    stream._na();
+  if (stream._ra)
+    stream._ra();
+};
+var _Disconn_n = function(stream) {
+  stream._na = null;
+  if (stream._n) {
+    stream._n.port.postMessage({ kill: true });
+    stream._n.disconnect();
+    stream._n = null;
+  }
+};
+var _Disconn_r = function(stream) {
+  stream._ra = null;
+  if (stream._r) {
+    stream._r.stop();
+    stream._r = null;
+  }
+};
+var Disconnect = function(streamStore) {
+  streamStore = streamStore || Recorder;
+  var isGlobal = streamStore == Recorder;
+  var stream = streamStore.Stream;
+  if (stream) {
+    if (stream._m) {
+      stream._m.disconnect();
+      stream._m = null;
+    }
+    if (!stream._RC && stream._c) {
+      Recorder.CloseNewCtx(stream._c);
+    }
+    stream._RC = null;
+    stream._c = null;
+    if (stream._d) {
+      StopS_(stream._d.stream);
+      stream._d = null;
+    }
+    if (stream._p) {
+      stream._p.disconnect();
+      stream._p.onaudioprocess = stream._p = null;
+    }
+    _Disconn_n(stream);
+    _Disconn_r(stream);
+    if (isGlobal) {
+      StopS_(stream);
+    }
+  }
+  streamStore.Stream = 0;
+};
+var StopS_ = Recorder.StopS_ = function(stream) {
+  var tracks = stream.getTracks && stream.getTracks() || stream.audioTracks || [];
+  for (var i = 0; i < tracks.length; i++) {
+    var track = tracks[i];
+    track.stop && track.stop();
+  }
+  stream.stop && stream.stop();
+};
+Recorder.SampleData = function(pcmDatas, pcmSampleRate, newSampleRate, prevChunkInfo, option) {
+  var Txt = "SampleData";
+  prevChunkInfo || (prevChunkInfo = {});
+  var index = prevChunkInfo.index || 0;
+  var offset = prevChunkInfo.offset || 0;
+  var filter = prevChunkInfo.filter;
+  if (filter && filter.fn && filter.sr != pcmSampleRate) {
+    filter = null;
+    CLog(Txt + "\u7684filter\u91C7\u6837\u7387\u53D8\u4E86\uFF0C\u91CD\u8BBE\u6EE4\u6CE2", 3);
+  }
+  if (!filter) {
+    var freq = newSampleRate > pcmSampleRate * 3 / 4 ? 0 : newSampleRate / 2 * 3 / 4;
+    filter = { fn: freq ? Recorder.IIRFilter(true, pcmSampleRate, freq) : 0 };
+  }
+  filter.sr = pcmSampleRate;
+  var filterFn = filter.fn;
+  var frameNext = prevChunkInfo.frameNext || [];
+  option || (option = {});
+  var frameSize = option.frameSize || 1;
+  if (option.frameType) {
+    frameSize = option.frameType == "mp3" ? 1152 : 1;
+  }
+  var nLen = pcmDatas.length;
+  if (index > nLen + 1) {
+    CLog(Txt + "\u4F3C\u4E4E\u4F20\u5165\u4E86\u672A\u91CD\u7F6Echunk " + index + ">" + nLen, 3);
+  }
+  var size = 0;
+  for (var i = index; i < nLen; i++) {
+    size += pcmDatas[i].length;
+  }
+  size = Math.max(0, size - Math.floor(offset));
+  var step = pcmSampleRate / newSampleRate;
+  if (step > 1) {
+    size = Math.floor(size / step);
+  } else {
+    step = 1;
+    newSampleRate = pcmSampleRate;
+  }
+  size += frameNext.length;
+  var res = new Int16Array(size);
+  var idx = 0;
+  for (var i = 0; i < frameNext.length; i++) {
+    res[idx] = frameNext[i];
+    idx++;
+  }
+  for (; index < nLen; index++) {
+    var o = pcmDatas[index];
+    var i = offset, il = o.length;
+    var F = filterFn && filterFn.Embed, F1 = 0, F2 = 0, Fx = 0, Fy = 0;
+    for (var i0 = 0, i2 = 0; i0 < il; i0++, i2++) {
+      if (i2 < il) {
+        if (F) {
+          Fx = o[i2];
+          Fy = F.b0 * Fx + F.b1 * F.x1 + F.b0 * F.x2 - F.a1 * F.y1 - F.a2 * F.y2;
+          F.x2 = F.x1;
+          F.x1 = Fx;
+          F.y2 = F.y1;
+          F.y1 = Fy;
+        } else {
+          Fy = filterFn ? filterFn(o[i2]) : o[i2];
+        }
+      }
+      F1 = F2;
+      F2 = Fy;
+      if (i2 == 0) {
+        i0--;
+        continue;
+      }
+      var before = Math.floor(i);
+      if (i0 != before)
+        continue;
+      var after = Math.ceil(i);
+      var atPoint = i - before;
+      var beforeVal = F1;
+      var afterVal = after < il ? F2 : beforeVal;
+      res[idx] = beforeVal + (afterVal - beforeVal) * atPoint;
+      idx++;
+      i += step;
+    }
+    offset = Math.max(0, i - il);
+  }
+  frameNext = null;
+  var frameNextSize = res.length % frameSize;
+  if (frameNextSize > 0) {
+    var u8Pos = (res.length - frameNextSize) * 2;
+    frameNext = new Int16Array(res.buffer.slice(u8Pos));
+    res = new Int16Array(res.buffer.slice(0, u8Pos));
+  }
+  return {
+    index,
+    offset,
+    filter,
+    frameNext,
+    sampleRate: newSampleRate,
+    data: res
+  };
+};
+Recorder.IIRFilter = function(useLowPass, sampleRate, freq) {
+  var ov = 2 * Math.PI * freq / sampleRate;
+  var sn = Math.sin(ov);
+  var cs = Math.cos(ov);
+  var alpha = sn / 2;
+  var a0 = 1 + alpha;
+  var a1 = -2 * cs / a0;
+  var a2 = (1 - alpha) / a0;
+  if (useLowPass) {
+    var b0 = (1 - cs) / 2 / a0;
+    var b1 = (1 - cs) / a0;
+  } else {
+    var b0 = (1 + cs) / 2 / a0;
+    var b1 = -(1 + cs) / a0;
+  }
+  var x1 = 0, x2 = 0, y = 0, y1 = 0, y2 = 0;
+  var fn = function(x) {
+    y = b0 * x + b1 * x1 + b0 * x2 - a1 * y1 - a2 * y2;
+    x2 = x1;
+    x1 = x;
+    y2 = y1;
+    y1 = y;
+    return y;
+  };
+  fn.Embed = { x1: 0, x2: 0, y1: 0, y2: 0, b0, b1, a1, a2 };
+  return fn;
+};
+Recorder.PowerLevel = function(pcmAbsSum, pcmLength) {
+  var power = pcmAbsSum / pcmLength || 0;
+  var level;
+  if (power < 1251) {
+    level = Math.round(power / 1250 * 10);
+  } else {
+    level = Math.round(Math.min(100, Math.max(0, (1 + Math.log(power / 1e4) / Math.log(10)) * 100)));
+  }
+  return level;
+};
+Recorder.PowerDBFS = function(maxSample) {
+  var val = Math.max(0.1, maxSample || 0), Pref = 32767;
+  val = Math.min(val, Pref);
+  val = 20 * Math.log(val / Pref) / Math.log(10);
+  return Math.max(-100, Math.round(val));
+};
+Recorder.CLog = function(msg, err) {
+  var now = new Date();
+  var t = ("0" + now.getMinutes()).substr(-2) + ":" + ("0" + now.getSeconds()).substr(-2) + "." + ("00" + now.getMilliseconds()).substr(-3);
+  var recID = this && this.envIn && this.envCheck && this.id;
+  var arr = ["[" + t + " " + RecTxt + (recID ? ":" + recID : "") + "]" + msg];
+  var a = arguments, console2 = window.console || {};
+  var i = 2, fn = console2.log;
+  if (typeof err == "number") {
+    fn = err == 1 ? console2.error : err == 3 ? console2.warn : fn;
+  } else {
+    i = 1;
+  }
+  for (; i < a.length; i++) {
+    arr.push(a[i]);
+  }
+  if (IsLoser) {
+    fn && fn("[IsLoser]" + arr[0], arr.length > 1 ? arr : "");
+  } else {
+    fn.apply(console2, arr);
+  }
+};
+var CLog = function() {
+  Recorder.CLog.apply(this, arguments);
+};
+var IsLoser = true;
+try {
+  IsLoser = !console.log.apply;
+} catch (e) {
+}
+var ID = 0;
+function initFn(set) {
+  this.id = ++ID;
+  Traffic();
+  var o = {
+    type: "mp3",
+    bitRate: 16,
+    sampleRate: 16e3,
+    onProcess: NOOP
+  };
+  for (var k in set) {
+    o[k] = set[k];
+  }
+  this.set = o;
+  this._S = 9;
+  this.Sync = { O: 9, C: 9 };
+}
+Recorder.Sync = { O: 9, C: 9 };
+Recorder.prototype = initFn.prototype = {
+  CLog,
+  _streamStore: function() {
+    if (this.set.sourceStream) {
+      return this;
+    } else {
+      return Recorder;
+    }
+  },
+  _streamCtx: function() {
+    var m = this._streamStore().Stream;
+    return m && m._c;
+  },
+  open: function(True, False) {
+    var This = this, set = This.set, streamStore = This._streamStore(), newCtx = 0;
+    True = True || NOOP;
+    var failCall = function(errMsg, isUserNotAllow) {
+      isUserNotAllow = !!isUserNotAllow;
+      This.CLog("\u5F55\u97F3open\u5931\u8D25\uFF1A" + errMsg + ",isUserNotAllow:" + isUserNotAllow, 1);
+      if (newCtx)
+        Recorder.CloseNewCtx(newCtx);
+      False && False(errMsg, isUserNotAllow);
+    };
+    var ok = function() {
+      This.CLog("open ok id:" + This.id);
+      True();
+      This._SO = 0;
+    };
+    var Lock = streamStore.Sync;
+    var lockOpen = ++Lock.O, lockClose = Lock.C;
+    This._O = This._O_ = lockOpen;
+    This._SO = This._S;
+    var lockFail = function() {
+      if (lockClose != Lock.C || !This._O) {
+        var err = "open\u88AB\u53D6\u6D88";
+        if (lockOpen == Lock.O) {
+          This.close();
+        } else {
+          err = "open\u88AB\u4E2D\u65AD";
+        }
+        failCall(err);
+        return true;
+      }
+    };
+    var checkMsg = This.envCheck({ envName: "H5", canProcess: true });
+    if (checkMsg) {
+      failCall("\u4E0D\u80FD\u5F55\u97F3\uFF1A" + checkMsg);
+      return;
+    }
+    if (set.sourceStream) {
+      if (!Recorder.GetContext()) {
+        failCall("\u4E0D\u652F\u6301\u6B64\u6D4F\u89C8\u5668\u4ECE\u6D41\u4E2D\u83B7\u53D6\u5F55\u97F3");
+        return;
+      }
+      Disconnect(streamStore);
+      var stream = This.Stream = set.sourceStream;
+      stream._RC = set.runningContext;
+      stream._call = {};
+      try {
+        Connect(streamStore);
+      } catch (e) {
+        Disconnect(streamStore);
+        failCall("\u4ECE\u6D41\u4E2D\u6253\u5F00\u5F55\u97F3\u5931\u8D25\uFF1A" + e.message);
+        return;
+      }
+      ok();
+      return;
+    }
+    var codeFail = function(code, msg) {
+      try {
+        window.top.a;
+      } catch (e) {
+        failCall('\u65E0\u6743\u5F55\u97F3(\u8DE8\u57DF\uFF0C\u8BF7\u5C1D\u8BD5\u7ED9iframe\u6DFB\u52A0\u9EA6\u514B\u98CE\u8BBF\u95EE\u7B56\u7565\uFF0C\u5982allow="camera;microphone")');
+        return;
+      }
+      if (/Permission|Allow/i.test(code)) {
+        failCall("\u7528\u6237\u62D2\u7EDD\u4E86\u5F55\u97F3\u6743\u9650", true);
+      } else if (window.isSecureContext === false) {
+        failCall("\u6D4F\u89C8\u5668\u7981\u6B62\u4E0D\u5B89\u5168\u9875\u9762\u5F55\u97F3\uFF0C\u53EF\u5F00\u542Fhttps\u89E3\u51B3");
+      } else if (/Found/i.test(code)) {
+        failCall(msg + "\uFF0C\u65E0\u53EF\u7528\u9EA6\u514B\u98CE");
+      } else {
+        failCall(msg);
+      }
+    };
+    if (Recorder.IsOpen()) {
+      ok();
+      return;
+    }
+    if (!Recorder.Support()) {
+      codeFail("", "\u6B64\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u5F55\u97F3");
+      return;
+    }
+    var ctx = set.runningContext;
+    if (!ctx)
+      ctx = newCtx = Recorder.GetContext(true);
+    var f1 = function(stream2) {
+      setTimeout(function() {
+        stream2._call = {};
+        var oldStream = Recorder.Stream;
+        if (oldStream) {
+          Disconnect();
+          stream2._call = oldStream._call;
+        }
+        Recorder.Stream = stream2;
+        stream2._c = ctx;
+        stream2._RC = set.runningContext;
+        if (lockFail())
+          return;
+        if (Recorder.IsOpen()) {
+          if (oldStream)
+            This.CLog("\u53D1\u73B0\u540C\u65F6\u591A\u6B21\u8C03\u7528open", 1);
+          Connect(streamStore, 1);
+          ok();
+        } else {
+          failCall("\u5F55\u97F3\u529F\u80FD\u65E0\u6548\uFF1A\u65E0\u97F3\u9891\u6D41");
+        }
+      }, 100);
+    };
+    var f2 = function(e) {
+      var code = e.name || e.message || e.code + ":" + e;
+      This.CLog("\u8BF7\u6C42\u5F55\u97F3\u6743\u9650\u9519\u8BEF", 1, e);
+      codeFail(code, "\u65E0\u6CD5\u5F55\u97F3\uFF1A" + code);
+    };
+    var trackSet = set.audioTrackSet || {};
+    trackSet[sampleRateTxt] = ctx[sampleRateTxt];
+    var mSet = { audio: trackSet };
+    try {
+      var pro = Recorder.Scope[getUserMediaTxt](mSet, f1, f2);
+    } catch (e) {
+      This.CLog(getUserMediaTxt, 3, e);
+      mSet = { audio: true };
+      pro = Recorder.Scope[getUserMediaTxt](mSet, f1, f2);
+    }
+    This.CLog(
+      getUserMediaTxt + "(" + JSON.stringify(mSet) + ") " + CtxState(ctx) + "\uFF0C\u4E00\u822C\u9ED8\u8BA4\u4F1A\u964D\u566A\u548C\u56DE\u58F0\u6D88\u9664\uFF0C\u79FB\u52A8\u7AEF\u53EF\u80FD\u4F1A\u964D\u4F4E\u7CFB\u7EDF\u64AD\u653E\u97F3\u91CF\uFF0C\u8BF7\u53C2\u9605\u6587\u6863\u4E2DaudioTrackSet\u914D\u7F6E"
+    );
+    if (pro && pro.then) {
+      pro.then(f1)[CatchTxt](f2);
+    }
+  },
+  close: function(call) {
+    call = call || NOOP;
+    var This = this, streamStore = This._streamStore();
+    This._stop();
+    var Lock = streamStore.Sync;
+    This._O = 0;
+    if (This._O_ != Lock.O) {
+      This.CLog("close\u88AB\u5FFD\u7565\uFF08\u56E0\u4E3A\u540C\u65F6open\u4E86\u591A\u4E2Arec\uFF0C\u53EA\u6709\u6700\u540E\u4E00\u4E2A\u4F1A\u771F\u6B63close\uFF09", 3);
+      call();
+      return;
+    }
+    Lock.C++;
+    Disconnect(streamStore);
+    This.CLog("close");
+    call();
+  },
+  mock: function(pcmData, pcmSampleRate) {
+    var This = this;
+    This._stop();
+    This.isMock = 1;
+    This.mockEnvInfo = null;
+    This.buffers = [pcmData];
+    This.recSize = pcmData.length;
+    This[srcSampleRateTxt] = pcmSampleRate;
+    return This;
+  },
+  envCheck: function(envInfo) {
+    var errMsg, This = this, set = This.set;
+    var tag = "CPU_BE";
+    if (!errMsg && !Recorder[tag] && window.Int8Array && !new Int8Array(new Int32Array([1]).buffer)[0]) {
+      Traffic(tag);
+      errMsg = "\u4E0D\u652F\u6301" + tag + "\u67B6\u6784";
+    }
+    if (!errMsg) {
+      var type = set.type;
+      if (This[type + "_envCheck"]) {
+        errMsg = This[type + "_envCheck"](envInfo, set);
+      } else {
+        if (set.takeoffEncodeChunk) {
+          errMsg = type + "\u7C7B\u578B" + (This[type] ? "" : "(\u672A\u52A0\u8F7D\u7F16\u7801\u5668)") + "\u4E0D\u652F\u6301\u8BBE\u7F6EtakeoffEncodeChunk";
+        }
+      }
+    }
+    return errMsg || "";
+  },
+  envStart: function(mockEnvInfo, sampleRate) {
+    var This = this, set = This.set;
+    This.isMock = mockEnvInfo ? 1 : 0;
+    This.mockEnvInfo = mockEnvInfo;
+    This.buffers = [];
+    This.recSize = 0;
+    This.envInLast = 0;
+    This.envInFirst = 0;
+    This.envInFix = 0;
+    This.envInFixTs = [];
+    var setSr = set[sampleRateTxt];
+    if (setSr > sampleRate) {
+      set[sampleRateTxt] = sampleRate;
+    } else {
+      setSr = 0;
+    }
+    This[srcSampleRateTxt] = sampleRate;
+    This.CLog(
+      srcSampleRateTxt + ": " + sampleRate + " set." + sampleRateTxt + ": " + set[sampleRateTxt] + (setSr ? " \u5FFD\u7565" + setSr : ""),
+      setSr ? 3 : 0
+    );
+    This.engineCtx = 0;
+    if (This[set.type + "_start"]) {
+      var engineCtx = This.engineCtx = This[set.type + "_start"](set);
+      if (engineCtx) {
+        engineCtx.pcmDatas = [];
+        engineCtx.pcmSize = 0;
+      }
+    }
+  },
+  envResume: function() {
+    this.envInFixTs = [];
+  },
+  envIn: function(pcm, sum) {
+    var This = this, set = This.set, engineCtx = This.engineCtx;
+    var bufferSampleRate = This[srcSampleRateTxt];
+    var size = pcm.length;
+    var powerLevel = Recorder.PowerLevel(sum, size);
+    var buffers = This.buffers;
+    var bufferFirstIdx = buffers.length;
+    buffers.push(pcm);
+    var buffersThis = buffers;
+    var bufferFirstIdxThis = bufferFirstIdx;
+    var now = Date.now();
+    var pcmTime = Math.round(size / bufferSampleRate * 1e3);
+    This.envInLast = now;
+    if (This.buffers.length == 1) {
+      This.envInFirst = now - pcmTime;
+    }
+    var envInFixTs = This.envInFixTs;
+    envInFixTs.splice(0, 0, { t: now, d: pcmTime });
+    var tsInStart = now, tsPcm = 0;
+    for (var i = 0; i < envInFixTs.length; i++) {
+      var o = envInFixTs[i];
+      if (now - o.t > 3e3) {
+        envInFixTs.length = i;
+        break;
+      }
+      tsInStart = o.t;
+      tsPcm += o.d;
+    }
+    var tsInPrev = envInFixTs[1];
+    var tsIn = now - tsInStart;
+    var lost = tsIn - tsPcm;
+    if (lost > tsIn / 3 && (tsInPrev && tsIn > 1e3 || envInFixTs.length >= 6)) {
+      var addTime = now - tsInPrev.t - pcmTime;
+      if (addTime > pcmTime / 5) {
+        var fixOpen = !set.disableEnvInFix;
+        This.CLog("[" + now + "]" + (fixOpen ? "" : "\u672A") + "\u8865\u507F" + addTime + "ms", 3);
+        This.envInFix += addTime;
+        if (fixOpen) {
+          var addPcm = new Int16Array(addTime * bufferSampleRate / 1e3);
+          size += addPcm.length;
+          buffers.push(addPcm);
+        }
+      }
+    }
+    var sizeOld = This.recSize, addSize = size;
+    var bufferSize = sizeOld + addSize;
+    This.recSize = bufferSize;
+    if (engineCtx) {
+      var chunkInfo = Recorder.SampleData(buffers, bufferSampleRate, set[sampleRateTxt], engineCtx.chunkInfo);
+      engineCtx.chunkInfo = chunkInfo;
+      sizeOld = engineCtx.pcmSize;
+      addSize = chunkInfo.data.length;
+      bufferSize = sizeOld + addSize;
+      engineCtx.pcmSize = bufferSize;
+      buffers = engineCtx.pcmDatas;
+      bufferFirstIdx = buffers.length;
+      buffers.push(chunkInfo.data);
+      bufferSampleRate = chunkInfo[sampleRateTxt];
+    }
+    var duration = Math.round(bufferSize / bufferSampleRate * 1e3);
+    var bufferNextIdx = buffers.length;
+    var bufferNextIdxThis = buffersThis.length;
+    var asyncEnd = function() {
+      var num = asyncBegin ? 0 : -addSize;
+      var hasClear2 = buffers[0] == null;
+      for (var i2 = bufferFirstIdx; i2 < bufferNextIdx; i2++) {
+        var buffer = buffers[i2];
+        if (buffer == null) {
+          hasClear2 = 1;
+        } else {
+          num += buffer.length;
+          if (engineCtx && buffer.length) {
+            This[set.type + "_encode"](engineCtx, buffer);
+          }
+        }
+      }
+      if (hasClear2 && engineCtx) {
+        var i2 = bufferFirstIdxThis;
+        if (buffersThis[0]) {
+          i2 = 0;
+        }
+        for (; i2 < bufferNextIdxThis; i2++) {
+          buffersThis[i2] = null;
+        }
+      }
+      if (hasClear2) {
+        num = asyncBegin ? addSize : 0;
+        buffers[0] = null;
+      }
+      if (engineCtx) {
+        engineCtx.pcmSize += num;
+      } else {
+        This.recSize += num;
+      }
+    };
+    var asyncBegin = 0, procTxt = "rec.set.onProcess";
+    try {
+      asyncBegin = set.onProcess(buffers, powerLevel, duration, bufferSampleRate, bufferFirstIdx, asyncEnd);
+    } catch (e) {
+      console.error(procTxt + "\u56DE\u8C03\u51FA\u9519\u662F\u4E0D\u5141\u8BB8\u7684\uFF0C\u9700\u4FDD\u8BC1\u4E0D\u4F1A\u629B\u5F02\u5E38", e);
+    }
+    var slowT = Date.now() - now;
+    if (slowT > 10 && This.envInFirst - now > 1e3) {
+      This.CLog(procTxt + "\u4F4E\u6027\u80FD\uFF0C\u8017\u65F6" + slowT + "ms", 3);
+    }
+    if (asyncBegin === true) {
+      var hasClear = 0;
+      for (var i = bufferFirstIdx; i < bufferNextIdx; i++) {
+        if (buffers[i] == null) {
+          hasClear = 1;
+        } else {
+          buffers[i] = new Int16Array(0);
+        }
+      }
+      if (hasClear) {
+        This.CLog("\u672A\u8FDB\u5165\u5F02\u6B65\u524D\u4E0D\u80FD\u6E05\u9664buffers", 3);
+      } else {
+        if (engineCtx) {
+          engineCtx.pcmSize -= addSize;
+        } else {
+          This.recSize -= addSize;
+        }
+      }
+    } else {
+      asyncEnd();
+    }
+  },
+  start: function() {
+    var This = this;
+    var isOpen = 1;
+    if (This.set.sourceStream) {
+      if (!This.Stream) {
+        isOpen = 0;
+      }
+    } else if (!Recorder.IsOpen()) {
+      isOpen = 0;
+    }
+    if (!isOpen) {
+      This.CLog("\u672Aopen", 1);
+      return;
+    }
+    var ctx = This._streamCtx();
+    This.CLog("start \u5F00\u59CB\u5F55\u97F3 " + CtxState(ctx));
+    This._stop();
+    This.state = 3;
+    This.envStart(null, ctx[sampleRateTxt]);
+    if (This._SO && This._SO + 1 != This._S) {
+      This.CLog("start\u88AB\u4E2D\u65AD", 3);
+      return;
+    }
+    This._SO = 0;
+    var end = function() {
+      if (This.state == 3) {
+        This.state = 1;
+        This.resume();
+      }
+    };
+    if (ctx.state == "suspended") {
+      var tag = "AudioContext resume: ";
+      This.CLog(tag + "wait...");
+      ctx.resume().then(function() {
+        This.CLog(tag + ctx.state);
+        end();
+      })[CatchTxt](function(e) {
+        This.CLog(tag + ctx.state + " \u53EF\u80FD\u65E0\u6CD5\u5F55\u97F3\uFF1A" + e.message, 1, e);
+        end();
+      });
+    } else {
+      end();
+    }
+  },
+  pause: function() {
+    var This = this;
+    if (This.state) {
+      This.state = 2;
+      This.CLog("pause");
+      delete This._streamStore().Stream._call[This.id];
+    }
+  },
+  resume: function() {
+    var This = this;
+    if (This.state) {
+      This.state = 1;
+      This.CLog("resume");
+      This.envResume();
+      var stream = This._streamStore().Stream;
+      stream._call[This.id] = function(pcm, sum) {
+        if (This.state == 1) {
+          This.envIn(pcm, sum);
+        }
+      };
+      ConnAlive(stream);
+    }
+  },
+  _stop: function(keepEngine) {
+    var This = this, set = This.set;
+    if (!This.isMock) {
+      This._S++;
+    }
+    if (This.state) {
+      This.pause();
+      This.state = 0;
+    }
+    if (!keepEngine && This[set.type + "_stop"]) {
+      This[set.type + "_stop"](This.engineCtx);
+      This.engineCtx = 0;
+    }
+  },
+  stop: function(True, False, autoClose) {
+    var This = this, set = This.set, t1;
+    var envInMS = This.envInLast - This.envInFirst, envInLen = envInMS && This.buffers.length;
+    This.CLog(
+      "stop \u548Cstart\u65F6\u5DEE" + (envInMS ? envInMS + "ms \u8865\u507F" + This.envInFix + "ms envIn:" + envInLen + " fps:" + (envInLen / envInMS * 1e3).toFixed(1) : "-") + " LM:" + Recorder.LM
+    );
+    var end = function() {
+      This._stop();
+      if (autoClose) {
+        This.close();
+      }
+    };
+    var err = function(msg) {
+      This.CLog("\u7ED3\u675F\u5F55\u97F3\u5931\u8D25\uFF1A" + msg, 1);
+      False && False(msg);
+      end();
+    };
+    var ok = function(blob, duration2) {
+      This.CLog("\u7ED3\u675F\u5F55\u97F3 \u7F16\u7801\u82B1" + (Date.now() - t1) + "ms \u97F3\u9891\u65F6\u957F" + duration2 + "ms \u6587\u4EF6\u5927\u5C0F" + blob.size + "b");
+      if (set.takeoffEncodeChunk) {
+        This.CLog("\u542F\u7528takeoffEncodeChunk\u540Estop\u8FD4\u56DE\u7684blob\u957F\u5EA6\u4E3A0\u4E0D\u63D0\u4F9B\u97F3\u9891\u6570\u636E", 3);
+      } else if (blob.size < Math.max(100, duration2 / 2)) {
+        err("\u751F\u6210\u7684" + set.type + "\u65E0\u6548");
+        return;
+      }
+      True && True(blob, duration2);
+      end();
+    };
+    if (!This.isMock) {
+      var isCtxWait = This.state == 3;
+      if (!This.state || isCtxWait) {
+        err("\u672A\u5F00\u59CB\u5F55\u97F3" + (isCtxWait ? "\uFF0C\u5F00\u59CB\u5F55\u97F3\u524D\u65E0\u7528\u6237\u4EA4\u4E92\u5BFC\u81F4AudioContext\u672A\u8FD0\u884C" : ""));
+        return;
+      }
+      This._stop(true);
+    }
+    var size = This.recSize;
+    if (!size) {
+      err("\u672A\u91C7\u96C6\u5230\u5F55\u97F3");
+      return;
+    }
+    if (!This.buffers[0]) {
+      err("\u97F3\u9891buffers\u88AB\u91CA\u653E");
+      return;
+    }
+    if (!This[set.type]) {
+      err("\u672A\u52A0\u8F7D" + set.type + "\u7F16\u7801\u5668");
+      return;
+    }
+    if (This.isMock) {
+      var checkMsg = This.envCheck(This.mockEnvInfo || { envName: "mock", canProcess: false });
+      if (checkMsg) {
+        err("\u5F55\u97F3\u9519\u8BEF\uFF1A" + checkMsg);
+        return;
+      }
+    }
+    var engineCtx = This.engineCtx;
+    if (This[set.type + "_complete"] && engineCtx) {
+      var duration = Math.round(engineCtx.pcmSize / set[sampleRateTxt] * 1e3);
+      t1 = Date.now();
+      This[set.type + "_complete"](
+        engineCtx,
+        function(blob) {
+          ok(blob, duration);
+        },
+        err
+      );
+      return;
+    }
+    t1 = Date.now();
+    var chunk = Recorder.SampleData(This.buffers, This[srcSampleRateTxt], set[sampleRateTxt]);
+    set[sampleRateTxt] = chunk[sampleRateTxt];
+    var res = chunk.data;
+    var duration = Math.round(res.length / set[sampleRateTxt] * 1e3);
+    This.CLog("\u91C7\u6837" + size + "->" + res.length + " \u82B1:" + (Date.now() - t1) + "ms");
+    setTimeout(function() {
+      t1 = Date.now();
+      This[set.type](
+        res,
+        function(blob) {
+          ok(blob, duration);
+        },
+        function(msg) {
+          err(msg);
+        }
+      );
+    });
+  }
+};
+var WebM_Extract = function(inBytes, scope) {
+  if (!scope.pos) {
+    scope.pos = [0];
+    scope.tracks = {};
+    scope.bytes = [];
+  }
+  var tracks = scope.tracks, position = [scope.pos[0]];
+  var endPos = function() {
+    scope.pos[0] = position[0];
+  };
+  var sBL = scope.bytes.length;
+  var bytes = new Uint8Array(sBL + inBytes.length);
+  bytes.set(scope.bytes);
+  bytes.set(inBytes, sBL);
+  scope.bytes = bytes;
+  if (!scope._ht) {
+    readMatroskaVInt(bytes, position);
+    readMatroskaBlock(bytes, position);
+    if (!BytesEq(readMatroskaVInt(bytes, position), [24, 83, 128, 103])) {
+      return;
+    }
+    readMatroskaVInt(bytes, position);
+    while (position[0] < bytes.length) {
+      var eid0 = readMatroskaVInt(bytes, position);
+      var bytes0 = readMatroskaBlock(bytes, position);
+      var pos0 = [0], audioIdx = 0;
+      if (!bytes0)
+        return;
+      if (BytesEq(eid0, [22, 84, 174, 107])) {
+        while (pos0[0] < bytes0.length) {
+          var eid1 = readMatroskaVInt(bytes0, pos0);
+          var bytes1 = readMatroskaBlock(bytes0, pos0);
+          var pos1 = [0], track = { channels: 0, sampleRate: 0 };
+          if (BytesEq(eid1, [174])) {
+            while (pos1[0] < bytes1.length) {
+              var eid2 = readMatroskaVInt(bytes1, pos1);
+              var bytes2 = readMatroskaBlock(bytes1, pos1);
+              var pos2 = [0];
+              if (BytesEq(eid2, [215])) {
+                var val = BytesInt(bytes2);
+                track.number = val;
+                tracks[val] = track;
+              } else if (BytesEq(eid2, [131])) {
+                var val = BytesInt(bytes2);
+                if (val == 1)
+                  track.type = "video";
+                else if (val == 2) {
+                  track.type = "audio";
+                  if (!audioIdx)
+                    scope.track0 = track;
+                  track.idx = audioIdx++;
+                } else
+                  track.type = "Type-" + val;
+              } else if (BytesEq(eid2, [134])) {
+                var str = "";
+                for (var i = 0; i < bytes2.length; i++) {
+                  str += String.fromCharCode(bytes2[i]);
+                }
+                track.codec = str;
+              } else if (BytesEq(eid2, [225])) {
+                while (pos2[0] < bytes2.length) {
+                  var eid3 = readMatroskaVInt(bytes2, pos2);
+                  var bytes3 = readMatroskaBlock(bytes2, pos2);
+                  if (BytesEq(eid3, [181])) {
+                    var val = 0, arr = new Uint8Array(bytes3.reverse()).buffer;
+                    if (bytes3.length == 4)
+                      val = new Float32Array(arr)[0];
+                    else if (bytes3.length == 8)
+                      val = new Float64Array(arr)[0];
+                    else
+                      CLog("WebM Track !Float", 1, bytes3);
+                    track[sampleRateTxt] = Math.round(val);
+                  } else if (BytesEq(eid3, [98, 100]))
+                    track.bitDepth = BytesInt(bytes3);
+                  else if (BytesEq(eid3, [159]))
+                    track.channels = BytesInt(bytes3);
+                }
+              }
+            }
+          }
+        }
+        scope._ht = 1;
+        CLog("WebM Tracks", tracks);
+        endPos();
+        break;
+      }
+    }
+  }
+  var track0 = scope.track0;
+  if (!track0)
+    return;
+  if (track0.bitDepth == 16 && /FLOAT/i.test(track0.codec)) {
+    track0.bitDepth = 32;
+    CLog("WebM 16\u653932\u4F4D", 3);
+  }
+  if (track0[sampleRateTxt] != scope[sampleRateTxt] || track0.bitDepth != 32 || track0.channels < 1 || !/(\b|_)PCM\b/i.test(track0.codec)) {
+    scope.bytes = [];
+    if (!scope.bad)
+      CLog("WebM Track\u975E\u9884\u671F", 3, scope);
+    scope.bad = 1;
+    return -1;
+  }
+  var datas = [], dataLen = 0;
+  while (position[0] < bytes.length) {
+    var eid1 = readMatroskaVInt(bytes, position);
+    var bytes1 = readMatroskaBlock(bytes, position);
+    if (!bytes1)
+      break;
+    if (BytesEq(eid1, [163])) {
+      var trackNo = bytes1[0] & 15;
+      var track = tracks[trackNo];
+      if (!track) {
+        CLog("WebM !Track" + trackNo, 1, tracks);
+      } else if (track.idx === 0) {
+        var u8arr = new Uint8Array(bytes1.length - 4);
+        for (var i = 4; i < bytes1.length; i++) {
+          u8arr[i - 4] = bytes1[i];
+        }
+        datas.push(u8arr);
+        dataLen += u8arr.length;
+      }
+    }
+    endPos();
+  }
+  if (dataLen) {
+    var more = new Uint8Array(bytes.length - scope.pos[0]);
+    more.set(bytes.subarray(scope.pos[0]));
+    scope.bytes = more;
+    scope.pos[0] = 0;
+    var u8arr = new Uint8Array(dataLen);
+    for (var i = 0, i2 = 0; i < datas.length; i++) {
+      u8arr.set(datas[i], i2);
+      i2 += datas[i].length;
+    }
+    var arr = new Float32Array(u8arr.buffer);
+    if (track0.channels > 1) {
+      var arr2 = [];
+      for (var i = 0; i < arr.length; ) {
+        arr2.push(arr[i]);
+        i += track0.channels;
+      }
+      arr = new Float32Array(arr2);
+    }
+    return arr;
+  }
+};
+var BytesEq = function(bytes1, bytes2) {
+  if (!bytes1 || bytes1.length != bytes2.length)
+    return false;
+  if (bytes1.length == 1)
+    return bytes1[0] == bytes2[0];
+  for (var i = 0; i < bytes1.length; i++) {
+    if (bytes1[i] != bytes2[i])
+      return false;
+  }
+  return true;
+};
+var BytesInt = function(bytes) {
+  var s = "";
+  for (var i = 0; i < bytes.length; i++) {
+    var n = bytes[i];
+    s += (n < 16 ? "0" : "") + n.toString(16);
+  }
+  return parseInt(s, 16) || 0;
+};
+var readMatroskaVInt = function(arr, pos, trim) {
+  var i = pos[0];
+  if (i >= arr.length)
+    return;
+  var b0 = arr[i], b2 = ("0000000" + b0.toString(2)).substr(-8);
+  var m = /^(0*1)(\d*)$/.exec(b2);
+  if (!m)
+    return;
+  var len = m[1].length, val = [];
+  if (i + len > arr.length)
+    return;
+  for (var i2 = 0; i2 < len; i2++) {
+    val[i2] = arr[i];
+    i++;
+  }
+  if (trim)
+    val[0] = parseInt(m[2] || "0", 2);
+  pos[0] = i;
+  return val;
+};
+var readMatroskaBlock = function(arr, pos) {
+  var lenVal = readMatroskaVInt(arr, pos, 1);
+  if (!lenVal)
+    return;
+  var len = BytesInt(lenVal);
+  var i = pos[0], val = [];
+  if (len < 2147483647) {
+    if (i + len > arr.length)
+      return;
+    for (var i2 = 0; i2 < len; i2++) {
+      val[i2] = arr[i];
+      i++;
+    }
+  }
+  pos[0] = i;
+  return val;
+};
+Recorder.TrafficImgUrl = "//ia.51.la/go1?id=20469973&pvFlag=1";
+var Traffic = Recorder.Traffic = function(report) {
+  report = report ? "/" + RecTxt + "/Report/" + report : "";
+  var imgUrl = Recorder.TrafficImgUrl;
+  if (imgUrl) {
+    var data = Recorder.Traffic;
+    var m = /^(https?:..[^\/#]*\/?)[^#]*/i.exec(location.href) || [];
+    var host = m[1] || "http://file/";
+    var idf = (m[0] || host) + report;
+    if (imgUrl.indexOf("//") == 0) {
+      if (/^https:/i.test(idf)) {
+        imgUrl = "https:" + imgUrl;
+      } else {
+        imgUrl = "http:" + imgUrl;
+      }
+    }
+    if (report) {
+      imgUrl = imgUrl + "&cu=" + encodeURIComponent(host + report);
+    }
+    if (!data[idf]) {
+      data[idf] = 1;
+      var img = new Image();
+      img.src = imgUrl;
+      CLog("Traffic Analysis Image: " + (report || RecTxt + ".TrafficImgUrl=" + Recorder.TrafficImgUrl));
+    }
+  }
+};
+
+export { Recorder as default };