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

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

@@ -0,0 +1,343 @@
+function useMP3(Recorder) {
+  Recorder.prototype.enc_mp3 = {
+    stable: true,
+    testmsg: "\u91C7\u6837\u7387\u8303\u56F448000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000"
+  };
+  Recorder.prototype.mp3 = function(res, True, False) {
+    var This = this, set = This.set, size = res.length;
+    var ctx = This.mp3_start(set);
+    if (ctx) {
+      This.mp3_encode(ctx, res);
+      This.mp3_complete(ctx, True, False, 1);
+      return;
+    }
+    var mp3 = new Recorder.lamejs.Mp3Encoder(1, set.sampleRate, set.bitRate);
+    var blockSize = 57600;
+    var data = [];
+    var idx = 0, mp3Size = 0;
+    var run = function() {
+      if (idx < size) {
+        var buf = mp3.encodeBuffer(res.subarray(idx, idx + blockSize));
+        if (buf.length > 0) {
+          mp3Size += buf.buffer.byteLength;
+          data.push(buf.buffer);
+        }
+        idx += blockSize;
+        setTimeout(run);
+      } else {
+        var buf = mp3.flush();
+        if (buf.length > 0) {
+          mp3Size += buf.buffer.byteLength;
+          data.push(buf.buffer);
+        }
+        var meta = mp3TrimFix.fn(data, mp3Size, size, set.sampleRate);
+        mp3TrimFixSetMeta(meta, set);
+        True(new Blob(data, { type: "audio/mp3" }));
+      }
+    };
+    run();
+  };
+  var mp3Worker;
+  Recorder.BindDestroy("mp3Worker", function() {
+    Recorder.CLog("mp3Worker Destroy");
+    mp3Worker && mp3Worker.terminate();
+    mp3Worker = null;
+  });
+  Recorder.prototype.mp3_envCheck = function(envInfo, set) {
+    var errMsg = "";
+    if (set.takeoffEncodeChunk) {
+      if (!envInfo.canProcess) {
+        errMsg = envInfo.envName + "\u73AF\u5883\u4E0D\u652F\u6301\u5B9E\u65F6\u5904\u7406";
+      } else if (!newContext()) {
+        errMsg = "\u5F53\u524D\u6D4F\u89C8\u5668\u7248\u672C\u592A\u4F4E\uFF0C\u65E0\u6CD5\u5B9E\u65F6\u5904\u7406";
+      }
+    }
+    return errMsg;
+  };
+  Recorder.prototype.mp3_start = function(set) {
+    return newContext(set);
+  };
+  var openList = { id: 0 };
+  var newContext = function(setOrNull) {
+    var worker = mp3Worker;
+    try {
+      if (!worker) {
+        var onmsg = function(e) {
+          var ed = e.data;
+          var cur = wk_ctxs[ed.id];
+          if (ed.action == "init") {
+            wk_ctxs[ed.id] = {
+              sampleRate: ed.sampleRate,
+              bitRate: ed.bitRate,
+              takeoff: ed.takeoff,
+              mp3Size: 0,
+              pcmSize: 0,
+              encArr: [],
+              encObj: new wk_lame.Mp3Encoder(1, ed.sampleRate, ed.bitRate)
+            };
+          } else if (!cur) {
+            return;
+          }
+          switch (ed.action) {
+            case "stop":
+              cur.encObj = null;
+              delete wk_ctxs[ed.id];
+              break;
+            case "encode":
+              cur.pcmSize += ed.pcm.length;
+              var buf = cur.encObj.encodeBuffer(ed.pcm);
+              if (buf.length > 0) {
+                if (cur.takeoff) {
+                  self.postMessage({ action: "takeoff", id: ed.id, chunk: buf });
+                } else {
+                  cur.mp3Size += buf.buffer.byteLength;
+                  cur.encArr.push(buf.buffer);
+                }
+              }
+              break;
+            case "complete":
+              var buf = cur.encObj.flush();
+              if (buf.length > 0) {
+                if (cur.takeoff) {
+                  self.postMessage({ action: "takeoff", id: ed.id, chunk: buf });
+                } else {
+                  cur.mp3Size += buf.buffer.byteLength;
+                  cur.encArr.push(buf.buffer);
+                }
+              }
+              var meta = wk_mp3TrimFix.fn(cur.encArr, cur.mp3Size, cur.pcmSize, cur.sampleRate);
+              self.postMessage({
+                action: ed.action,
+                id: ed.id,
+                blob: new Blob(cur.encArr, { type: "audio/mp3" }),
+                meta
+              });
+              break;
+          }
+        };
+        var jsCode = ");wk_lame();var wk_ctxs={};self.onmessage=" + onmsg;
+        jsCode += ";var wk_mp3TrimFix={rm:" + mp3TrimFix.rm + ",fn:" + mp3TrimFix.fn + "}";
+        var lamejsCode = Recorder.lamejs.toString();
+        var url = (window.URL || webkitURL).createObjectURL(
+          new Blob(["var wk_lame=(", lamejsCode, jsCode], { type: "text/javascript" })
+        );
+        worker = new Worker(url);
+        setTimeout(function() {
+          (window.URL || webkitURL).revokeObjectURL(url);
+        }, 1e4);
+        worker.onmessage = function(e) {
+          var data = e.data;
+          var ctx2 = openList[data.id];
+          if (ctx2) {
+            if (data.action == "takeoff") {
+              ctx2.set.takeoffEncodeChunk(new Uint8Array(data.chunk.buffer));
+            } else {
+              ctx2.call && ctx2.call(data);
+              ctx2.call = null;
+            }
+          }
+        };
+      }
+      var ctx = { worker, set: setOrNull, takeoffQueue: [] };
+      if (setOrNull) {
+        ctx.id = ++openList.id;
+        openList[ctx.id] = ctx;
+        worker.postMessage({
+          action: "init",
+          id: ctx.id,
+          sampleRate: setOrNull.sampleRate,
+          bitRate: setOrNull.bitRate,
+          takeoff: !!setOrNull.takeoffEncodeChunk,
+          x: new Int16Array(5)
+        });
+      } else {
+        worker.postMessage({
+          x: new Int16Array(5)
+        });
+      }
+      mp3Worker = worker;
+      return ctx;
+    } catch (e) {
+      worker && worker.terminate();
+      console.error(e);
+      return null;
+    }
+  };
+  Recorder.prototype.mp3_stop = function(startCtx) {
+    if (startCtx && startCtx.worker) {
+      startCtx.worker.postMessage({
+        action: "stop",
+        id: startCtx.id
+      });
+      startCtx.worker = null;
+      delete openList[startCtx.id];
+      var opens = -1;
+      for (var k in openList) {
+        opens++;
+      }
+      if (opens) {
+        Recorder.CLog("mp3 worker\u5269" + opens + "\u4E2A\u5728\u4E32\u884C\u7B49\u5F85", 3);
+      }
+    }
+  };
+  Recorder.prototype.mp3_encode = function(startCtx, pcm) {
+    if (startCtx && startCtx.worker) {
+      startCtx.worker.postMessage({
+        action: "encode",
+        id: startCtx.id,
+        pcm
+      });
+    }
+  };
+  Recorder.prototype.mp3_complete = function(startCtx, True, False, autoStop) {
+    var This = this;
+    if (startCtx && startCtx.worker) {
+      startCtx.call = function(data) {
+        mp3TrimFixSetMeta(data.meta, startCtx.set);
+        True(data.blob);
+        if (autoStop) {
+          This.mp3_stop(startCtx);
+        }
+      };
+      startCtx.worker.postMessage({
+        action: "complete",
+        id: startCtx.id
+      });
+    } else {
+      False("mp3\u7F16\u7801\u5668\u672A\u6253\u5F00");
+    }
+  };
+  Recorder.mp3ReadMeta = function(mp3Buffers, length) {
+    var parseInt_ES3 = typeof window == "object" ? window.parseInt : self.parseInt;
+    var u8arr0 = new Uint8Array(mp3Buffers[0] || []);
+    if (u8arr0.length < 4) {
+      return null;
+    }
+    var byteAt = function(idx2, u8) {
+      return ("0000000" + ((u8 || u8arr0)[idx2] || 0).toString(2)).substr(-8);
+    };
+    var b2 = byteAt(0) + byteAt(1);
+    var b4 = byteAt(2) + byteAt(3);
+    if (!/^1{11}/.test(b2)) {
+      return null;
+    }
+    var version = { "00": 2.5, 10: 2, 11: 1 }[b2.substr(11, 2)];
+    var layer = { "01": 3 }[b2.substr(13, 2)];
+    var sampleRate = {
+      1: [44100, 48e3, 32e3],
+      2: [22050, 24e3, 16e3],
+      2.5: [11025, 12e3, 8e3]
+    }[version];
+    sampleRate && (sampleRate = sampleRate[parseInt_ES3(b4.substr(4, 2), 2)]);
+    var bitRate = [
+      [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160],
+      [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320]
+    ][version == 1 ? 1 : 0][parseInt_ES3(b4.substr(0, 4), 2)];
+    if (!version || !layer || !bitRate || !sampleRate) {
+      return null;
+    }
+    var duration = Math.round(length * 8 / bitRate);
+    var frame = layer == 1 ? 384 : layer == 2 ? 1152 : version == 1 ? 1152 : 576;
+    var frameDurationFloat = frame / sampleRate * 1e3;
+    var frameSize = Math.floor(frame * bitRate / 8 / sampleRate * 1e3);
+    var hasPadding = 0, seek = 0;
+    for (var i = 0; i < mp3Buffers.length; i++) {
+      var buf = mp3Buffers[i];
+      seek += buf.byteLength;
+      if (seek >= frameSize + 3) {
+        var buf8 = new Uint8Array(buf);
+        var idx = buf.byteLength - (seek - (frameSize + 3) + 1);
+        var ib4 = byteAt(idx, buf8);
+        hasPadding = ib4.charAt(6) == "1";
+        break;
+      }
+    }
+    if (hasPadding) {
+      frameSize++;
+    }
+    return {
+      version,
+      layer,
+      sampleRate,
+      bitRate,
+      duration,
+      size: length,
+      hasPadding,
+      frameSize,
+      frameDurationFloat
+    };
+  };
+  var mp3TrimFix = {
+    rm: Recorder.mp3ReadMeta,
+    fn: function(mp3Buffers, length, pcmLength, pcmSampleRate) {
+      var meta = this.rm(mp3Buffers, length);
+      if (!meta) {
+        return { err: "mp3\u975E\u9884\u5B9A\u683C\u5F0F" };
+      }
+      var pcmDuration = Math.round(pcmLength / pcmSampleRate * 1e3);
+      var num = Math.floor((meta.duration - pcmDuration) / meta.frameDurationFloat);
+      if (num > 0) {
+        var size = num * meta.frameSize - (meta.hasPadding ? 1 : 0);
+        length -= size;
+        var arr0 = 0, arrs = [];
+        for (var i = 0; i < mp3Buffers.length; i++) {
+          var arr = mp3Buffers[i];
+          if (size <= 0) {
+            break;
+          }
+          if (size >= arr.byteLength) {
+            size -= arr.byteLength;
+            arrs.push(arr);
+            mp3Buffers.splice(i, 1);
+            i--;
+          } else {
+            mp3Buffers[i] = arr.slice(size);
+            arr0 = arr;
+            size = 0;
+          }
+        }
+        var checkMeta = this.rm(mp3Buffers, length);
+        if (!checkMeta) {
+          arr0 && (mp3Buffers[0] = arr0);
+          for (var i = 0; i < arrs.length; i++) {
+            mp3Buffers.splice(i, 0, arrs[i]);
+          }
+          meta.err = "fix\u540E\u6570\u636E\u9519\u8BEF\uFF0C\u5DF2\u8FD8\u539F\uFF0C\u9519\u8BEF\u539F\u56E0\u4E0D\u660E";
+        }
+        var fix = meta.trimFix = {};
+        fix.remove = num;
+        fix.removeDuration = Math.round(num * meta.frameDurationFloat);
+        fix.duration = Math.round(length * 8 / meta.bitRate);
+      }
+      return meta;
+    }
+  };
+  var mp3TrimFixSetMeta = function(meta, set) {
+    var tag = "MP3\u4FE1\u606F ";
+    if (meta.sampleRate && meta.sampleRate != set.sampleRate || meta.bitRate && meta.bitRate != set.bitRate) {
+      Recorder.CLog(
+        tag + "\u548C\u8BBE\u7F6E\u7684\u4E0D\u5339\u914Dset:" + set.bitRate + "kbps " + set.sampleRate + "hz\uFF0C\u5DF2\u66F4\u65B0set:" + meta.bitRate + "kbps " + meta.sampleRate + "hz",
+        3,
+        set
+      );
+      set.sampleRate = meta.sampleRate;
+      set.bitRate = meta.bitRate;
+    }
+    var trimFix = meta.trimFix;
+    if (trimFix) {
+      tag += "Fix\u79FB\u9664" + trimFix.remove + "\u5E27" + trimFix.removeDuration + "ms -> " + trimFix.duration + "ms";
+      if (trimFix.remove > 2) {
+        meta.err = (meta.err ? meta.err + ", " : "") + "\u79FB\u9664\u5E27\u6570\u8FC7\u591A";
+      }
+    } else {
+      tag += (meta.duration || "-") + "ms";
+    }
+    if (meta.err) {
+      Recorder.CLog(tag, 1, meta.err, meta);
+    } else {
+      Recorder.CLog(tag, meta);
+    }
+  };
+}
+
+export { useMP3 };