var __renderjsModules={};

__renderjsModules["49b84592"] = (() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  var __async = (__this, __arguments, generator) => {
    return new Promise((resolve, reject) => {
      var fulfilled = (value) => {
        try {
          step(generator.next(value));
        } catch (e) {
          reject(e);
        }
      };
      var rejected = (value) => {
        try {
          step(generator.throw(value));
        } catch (e) {
          reject(e);
        }
      };
      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
      step((generator = generator.apply(__this, __arguments)).next());
    });
  };

  // <stdin>
  var stdin_exports = {};
  __export(stdin_exports, {
    default: () => stdin_default
  });

  // C:/Users/1/Desktop/testAudio/测试流式传输uniapp/pages/index/StreamPlayer.js
  var StreamPlayer = class {
    constructor({
      inputSampleRate = 16e3,
      numChannels = 1,
      bitDepth = 16,
      littleEndian = true,
      pcmType = "int",
      callback = () => {
      }
    } = {}) {
      if (![16, 32].includes(bitDepth))
        throw new Error("bitDepth \u5FC5\u987B\u662F 16 \u6216 32");
      if (inputSampleRate <= 0)
        throw new Error("\u91C7\u6837\u7387\u5FC5\u987B\u5927\u4E8E 0");
      if (!["int", "float"].includes(pcmType))
        throw new Error("pcmType \u5FC5\u987B\u662F int \u6216 float");
      this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
      this.inputSampleRate = inputSampleRate;
      this.numChannels = numChannels;
      this.bitDepth = bitDepth;
      this.littleEndian = littleEndian;
      this.pcmType = pcmType;
      this.audioQueue = [];
      this.playbackEndTime = 0;
      this.currentSource = null;
      this.lastBlockTail = null;
      this.callback = callback;
    }
    appendChunk(audioData) {
      console.log("this.audioQueue", this.audioQueue.length);
      this.audioQueue.push(audioData);
      this._processQueue();
    }
    destroy() {
      this.audioQueue = [];
      this.playbackEndTime = 0;
      if (this.currentSource) {
        this.currentSource.stop();
        this.currentSource = null;
      }
      if (this.audioContext) {
        this.audioContext.close();
        this.audioContext = null;
      }
    }
    _processQueue() {
      return __async(this, null, function* () {
        if (this.audioQueue.length === 0) {
          this.callback("ended");
          return;
        }
        if (!this.audioContext || this.currentSource)
          return;
        const buffer = this._mergeArrayBuffers(this.audioQueue);
        this.audioQueue = [];
        try {
          const audioBuffer = this._convertPCM(buffer);
          yield this._schedulePlay(audioBuffer);
          this._processQueue();
        } catch (err) {
          console.error("\u97F3\u9891\u5904\u7406\u5931\u8D25:", err.name, err.message, err.stack);
        }
      });
    }
    _convertPCM(buffer) {
      const bytesPerSample = this.bitDepth / 8;
      const requiredBytes = bytesPerSample * this.numChannels;
      const validByteLength = Math.floor(buffer.byteLength / requiredBytes) * requiredBytes;
      const validBuffer = buffer.slice(0, validByteLength);
      const dataView = new DataView(validBuffer);
      const numSamples = validByteLength / requiredBytes;
      const audioBuffer = this.audioContext.createBuffer(
        this.numChannels,
        numSamples,
        this.inputSampleRate
      );
      for (let ch = 0; ch < this.numChannels; ch++) {
        const channelData = audioBuffer.getChannelData(ch);
        for (let i = 0; i < numSamples; i++) {
          const pos = i * this.numChannels * bytesPerSample + ch * bytesPerSample;
          let value;
          if (this.bitDepth === 16) {
            value = dataView.getInt16(pos, this.littleEndian) / 32768;
          } else {
            if (this.pcmType === "int") {
              value = dataView.getInt32(pos, this.littleEndian) / 2147483648;
            } else {
              value = dataView.getFloat32(pos, this.littleEndian);
            }
          }
          channelData[i] = value;
        }
        let sum = 0;
        for (let i = 0; i < channelData.length; i++) {
          sum += channelData[i];
        }
        const dcOffset = sum / channelData.length;
        for (let i = 0; i < channelData.length; i++) {
          channelData[i] -= dcOffset;
        }
        const fadeLength = Math.min(100, channelData.length);
        for (let i = 0; i < fadeLength; i++) {
          channelData[i] *= i / fadeLength;
        }
        const startFadeOut = Math.max(0, channelData.length - fadeLength);
        for (let i = startFadeOut; i < channelData.length; i++) {
          const factor = 1 - (i - startFadeOut) / fadeLength;
          channelData[i] *= factor;
        }
      }
      const crossfadeLength = 50;
      if (this.lastBlockTail && this.lastBlockTail.length === this.numChannels) {
        for (let ch = 0; ch < this.numChannels; ch++) {
          const channelData = audioBuffer.getChannelData(ch);
          const prevTail = this.lastBlockTail[ch];
          if (prevTail.length >= crossfadeLength && channelData.length >= crossfadeLength) {
            for (let i = 0; i < crossfadeLength; i++) {
              const prevWeight = (crossfadeLength - i) / crossfadeLength;
              const currWeight = i / crossfadeLength;
              channelData[i] = channelData[i] * currWeight + prevTail[i] * prevWeight;
            }
          }
        }
      }
      this.lastBlockTail = [];
      for (let ch = 0; ch < this.numChannels; ch++) {
        const channelData = audioBuffer.getChannelData(ch);
        const tailStart = Math.max(0, channelData.length - crossfadeLength);
        this.lastBlockTail[ch] = channelData.slice(tailStart);
      }
      return audioBuffer;
    }
    _schedulePlay(audioBuffer) {
      return new Promise((resolve) => {
        const source = this.audioContext.createBufferSource();
        source.buffer = audioBuffer;
        source.connect(this.audioContext.destination);
        const plannedStartTime = this.playbackEndTime;
        const now = this.audioContext.currentTime;
        let startTime = Math.max(plannedStartTime, now);
        const timeDrift = plannedStartTime - now;
        if (timeDrift < -0.02) {
          source.playbackRate.value = Math.min(1.04, 1 - timeDrift / audioBuffer.duration);
        } else if (timeDrift > 0.02) {
          source.playbackRate.value = Math.max(0.96, 1 - timeDrift / audioBuffer.duration);
        } else {
          source.playbackRate.value = 1;
        }
        source.start(startTime);
        this.playbackEndTime = startTime + audioBuffer.duration / source.playbackRate.value;
        source.onended = () => {
          this.currentSource = null;
          resolve();
        };
        this.currentSource = source;
      });
    }
    // 合并多个 ArrayBuffer 的辅助函数
    _mergeArrayBuffers(buffers) {
      let totalLength = 0;
      for (let buffer of buffers) {
        totalLength += buffer.byteLength;
      }
      const result = new Uint8Array(totalLength);
      let offset = 0;
      for (let buffer of buffers) {
        const view = new Uint8Array(buffer);
        result.set(view, offset);
        offset += view.length;
      }
      return result.buffer;
    }
  };

  // <stdin>
  var player = null;
  var stdin_default = {
    mounted() {
      const _this = this;
      player = new StreamPlayer({
        inputSampleRate: 44100,
        // 后端PCM采样率（如8000/24000）
        numChannels: 1,
        // 声道数（单声道/双声道）
        bitDepth: 16,
        // 位深（16/32bit）
        littleEndian: true,
        // 端序（和后端一致）
        pcmType: "int",
        // 类型（int/float）
        callback: _this.callback
      });
    },
    methods: {
      appendPCMChunk(numArray) {
        if (!numArray || numArray.length === 0)
          return;
        const uint8 = new Uint8Array(numArray);
        const arrayBuffer = uint8.buffer;
        player.appendChunk(arrayBuffer);
      },
      // 停止播放（销毁播放器）
      stop() {
        if (player) {
          player.destroy();
          player = null;
          const _this = this;
          player = new StreamPlayer({
            inputSampleRate: 16e3,
            numChannels: 1,
            bitDepth: 16,
            littleEndian: true,
            pcmType: "int",
            callback: _this.callback
          });
        }
      },
      // 播放结束回调（通知主线程）
      callback(e) {
        if (e === "ended") {
          this.$ownerInstance.callMethod("changeStreamPlaying", { type: false });
        }
      }
    }
  };
  return __toCommonJS(stdin_exports);
})();


__renderjsModules["1e54c19a"] = (() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  var __async = (__this, __arguments, generator) => {
    return new Promise((resolve, reject) => {
      var fulfilled = (value) => {
        try {
          step(generator.next(value));
        } catch (e) {
          reject(e);
        }
      };
      var rejected = (value) => {
        try {
          step(generator.throw(value));
        } catch (e) {
          reject(e);
        }
      };
      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
      step((generator = generator.apply(__this, __arguments)).next());
    });
  };

  // <stdin>
  var stdin_exports = {};
  __export(stdin_exports, {
    default: () => stdin_default
  });
  var mediaStream;
  var audioContext;
  var processor;
  var recordedChunks = [];
  var decibelHistory = [];
  var DB_CONFIG = {
    minDecibels: -80,
    // 最小可测分贝
    maxDecibels: -30,
    // 最大可测分贝
    smoothingTimeConstant: 0.8
    // 平滑系数，使分贝变化更平缓
  };
  var stdin_default = {
    data() {
      return {};
    },
    methods: {
      startRecord(options) {
        return __async(this, null, function* () {
          if (options == null)
            return;
          if (audioContext)
            return;
          try {
            var a, i = options.sampleRate, s = options.frameSize;
            if (options.gain < 1) {
              options.gain = 1;
            }
            if (options.gain > 20) {
              options.gain = 20;
            }
            audioContext = new AudioContext();
            yield audioContext.audioWorklet.addModule("static/dist/processor.worklet.js");
            mediaStream = yield navigator.mediaDevices.getUserMedia({
              audio: {
                sampleRate: options.sampleRate,
                channelCount: 1
              }
            });
            const source = audioContext.createMediaStreamSource(mediaStream);
            processor = new AudioWorkletNode(audioContext, "processor-worklet");
            processor.port.postMessage({
              type: "init",
              data: {
                frameSize: options.frameSize,
                // 样本数 (1280字节 / 2字节每样本)
                fromSampleRate: 48e3,
                // 输入采样率
                toSampleRate: options.sampleRate,
                // 输出采样率 (1/3)
                arrayBufferType: "short16",
                gain: options.gain
              }
            });
            processor.port.onmessage = (t) => {
              var r = t.data, o = r.frameBuffer, n = r.isLastFrame;
              if (o && o.byteLength > 0) {
                const decibels = this.calculateDecibels(o);
                this.onDecibelsCalculated(decibels);
                decibelHistory.push(decibels);
                if (decibelHistory.length > 100) {
                  decibelHistory.shift();
                }
              }
              if (null == o ? void 0 : o.byteLength)
                for (var a2 = 0; a2 < o.byteLength; ) {
                  const frameData = {
                    isLastFrame: n && a2 + s >= o.byteLength,
                    frameBuffer: t.data.frameBuffer.slice(a2, a2 + s)
                  };
                  this.onFrameRecorded(frameData);
                  recordedChunks.push(frameData.frameBuffer);
                  a2 += s;
                }
              else
                this.onFrameRecorded(t.data);
            };
            source.connect(processor);
            processor.connect(audioContext.destination);
          } catch (err) {
            this.$ownerInstance.callMethod("toShowToast");
          }
        });
      },
      onFrameRecorded({
        isLastFrame,
        frameBuffer
      }) {
        this.$ownerInstance.callMethod("frameRecorded", {
          isLastFrame,
          frameBuffer: this.toBase64(frameBuffer)
        });
      },
      calculateDecibels(frameBuffer) {
        try {
          const samples = new Int16Array(frameBuffer);
          let sum = 0;
          for (let i = 0; i < samples.length; i++) {
            const value = samples[i] / 32768;
            sum += value * value;
          }
          const rms = Math.sqrt(sum / samples.length);
          if (rms < 1e-5) {
            return DB_CONFIG.minDecibels;
          }
          let db = 20 * Math.log10(rms);
          if (decibelHistory.length > 0) {
            const lastDb = decibelHistory[decibelHistory.length - 1];
            db = lastDb * DB_CONFIG.smoothingTimeConstant + db * (1 - DB_CONFIG.smoothingTimeConstant);
          }
          return Math.max(DB_CONFIG.minDecibels, Math.min(DB_CONFIG.maxDecibels, db));
        } catch (e) {
          console.error("\u8BA1\u7B97\u5206\u8D1D\u65F6\u51FA\u9519:", e);
          return DB_CONFIG.minDecibels;
        }
      },
      onDecibelsCalculated(decibels) {
        this.$ownerInstance.callMethod("decibels", decibels.toFixed(1));
      },
      toBase64(buffer) {
        let binary = "";
        const bytes = new Uint8Array(buffer);
        const len = bytes.byteLength;
        for (let i = 0; i < len; i++) {
          binary += String.fromCharCode(bytes[i]);
        }
        return window.btoa(binary);
      },
      onRecordedChunks(chunks) {
        return __async(this, null, function* () {
          var mergedBuffer = this.mergeAudioBuffers(chunks);
          const wavBlob = this.createWavBlob(mergedBuffer, 1, 16e3);
          const base64 = yield this.blobToBase64(wavBlob);
          this.$ownerInstance.callMethod("recordedChunks", base64);
        });
      },
      onStop(value) {
        if (value !== "stop")
          return;
        this.onFrameRecorded({
          isLastFrame: true,
          frameBuffer: ""
        });
        this.onRecordedChunks(recordedChunks);
        recordedChunks = [];
        if (mediaStream) {
          mediaStream.getTracks().forEach((track) => track.stop());
          mediaStream = null;
        }
        if (processor) {
          processor.disconnect();
          processor = null;
        }
        if (audioContext) {
          audioContext.close().then(() => {
            audioContext = null;
          });
        }
      },
      //合并所有buffer
      mergeAudioBuffers(buffers) {
        let totalLength = buffers.reduce((acc, buf) => acc + buf.byteLength, 0);
        const result = new Uint8Array(totalLength);
        let offset = 0;
        buffers.forEach((buffer) => {
          result.set(new Uint8Array(buffer), offset);
          offset += buffer.byteLength;
        });
        if (offset !== totalLength)
          console.error("\u5408\u5E76\u540E\u7684\u957F\u5EA6\u4E0D\u7B26\uFF01");
        return result.buffer;
      },
      // 新增WAV封装函数（基于前序回答的createWavBlob）
      createWavBlob(pcmData, numChannels, sampleRate) {
        const bytesPerSample = 2;
        const blockAlign = numChannels * bytesPerSample;
        const byteRate = sampleRate * blockAlign;
        const bufferLength = pcmData.byteLength;
        const totalLength = 44 + bufferLength;
        const buffer = new ArrayBuffer(totalLength);
        const view = new DataView(buffer);
        this.writeString(view, 0, "RIFF");
        view.setUint32(4, totalLength - 8, true);
        this.writeString(view, 8, "WAVE");
        this.writeString(view, 12, "fmt ");
        view.setUint32(16, 16, true);
        view.setUint16(20, 1, true);
        view.setUint16(22, numChannels, true);
        view.setUint32(24, sampleRate, true);
        view.setUint32(28, byteRate, true);
        view.setUint16(32, blockAlign, true);
        view.setUint16(34, 16, true);
        this.writeString(view, 36, "data");
        view.setUint32(40, bufferLength, true);
        const pcm16 = new Int16Array(pcmData);
        for (let i = 0; i < pcm16.length; i++) {
          view.setInt16(44 + i * 2, pcm16[i], true);
        }
        return new Blob([buffer], {
          type: "audio/wav"
        });
      },
      // 辅助函数：Blob转Base64
      blobToBase64(blob) {
        return new Promise((resolve, reject) => {
          const reader = new FileReader();
          reader.onloadend = () => resolve(reader.result);
          reader.onerror = reject;
          reader.readAsDataURL(blob);
        });
      },
      // 辅助函数：字符串写入DataView
      writeString(view, offset, string) {
        for (let i = 0; i < string.length; i++) {
          view.setUint8(offset + i, string.charCodeAt(i));
        }
      }
    }
  };
  return __toCommonJS(stdin_exports);
})();