ibi-ai-talk 1.0.0

package/src/utils/opus-codec.js

@@ -0,0 +1,169 @@
+// 检查Opus库是否已加载
+export function checkOpusLoaded() {
+    try {
+        // 检查Module是否存在（本地库导出的全局变量）
+        if (typeof Module === 'undefined') {
+            throw new Error('Opus库未加载，Module对象不存在');
+        }
+
+        // 尝试先使用Module.instance（libopus.js最后一行导出方式）
+        if (typeof Module.instance !== 'undefined' && typeof Module.instance._opus_decoder_get_size === 'function') {
+            // 使用Module.instance对象替换全局Module对象
+            window.ModuleInstance = Module.instance;
+            console.log('Opus库加载成功（使用Module.instance）', 'success');
+        }
+
+        // 如果没有Module.instance，检查全局Module函数
+        if (typeof Module._opus_decoder_get_size === 'function') {
+            window.ModuleInstance = Module;
+            console.log('Opus库加载成功（使用全局Module）', 'success');
+        }
+
+        throw new Error('Opus解码函数未找到，可能Module结构不正确');
+    } catch (err) {
+        console.log(`Opus库加载失败，请检查libopus.js文件是否存在且正确: ${err.message}`, 'error');
+    }
+}
+
+
+// 创建一个Opus编码器
+let opusEncoder = null;
+export function initOpusEncoder() {
+    try {
+        if (opusEncoder) {
+            return opusEncoder; // 已经初始化过
+        }
+
+        if (!window.ModuleInstance) {
+            console.log('无法创建Opus编码器：ModuleInstance不可用', 'error');
+            return;
+        }
+
+        // 初始化一个Opus编码器
+        const mod = window.ModuleInstance;
+        const sampleRate = 16000; // 16kHz采样率
+        const channels = 1;       // 单声道
+        const application = 2048; // OPUS_APPLICATION_VOIP = 2048
+
+        // 创建编码器
+        opusEncoder = {
+            channels: channels,
+            sampleRate: sampleRate,
+            frameSize: 960, // 60ms @ 16kHz = 60 * 16 = 960 samples
+            maxPacketSize: 4000, // 最大包大小
+            module: mod,
+
+            // 初始化编码器
+            init: function () {
+                try {
+                    // 获取编码器大小
+                    const encoderSize = mod._opus_encoder_get_size(this.channels);
+                    console.log(`Opus编码器大小: ${encoderSize}字节`, 'info');
+
+                    // 分配内存
+                    this.encoderPtr = mod._malloc(encoderSize);
+                    if (!this.encoderPtr) {
+                        throw new Error("无法分配编码器内存");
+                    }
+
+                    // 初始化编码器
+                    const err = mod._opus_encoder_init(
+                        this.encoderPtr,
+                        this.sampleRate,
+                        this.channels,
+                        application
+                    );
+
+                    if (err < 0) {
+                        throw new Error(`Opus编码器初始化失败: ${err}`);
+                    }
+
+                    // 设置位率 (16kbps)
+                    mod._opus_encoder_ctl(this.encoderPtr, 4002, 16000); // OPUS_SET_BITRATE
+
+                    // 设置复杂度 (0-10, 越高质量越好但CPU使用越多)
+                    mod._opus_encoder_ctl(this.encoderPtr, 4010, 5);     // OPUS_SET_COMPLEXITY
+
+                    // 设置使用DTX (不传输静音帧)
+                    mod._opus_encoder_ctl(this.encoderPtr, 4016, 1);     // OPUS_SET_DTX
+
+                    console.log("Opus编码器初始化成功", 'success');
+                    return true;
+                } catch (error) {
+                    if (this.encoderPtr) {
+                        mod._free(this.encoderPtr);
+                        this.encoderPtr = null;
+                    }
+                    console.log(`Opus编码器初始化失败: ${error.message}`, 'error');
+                    return false;
+                }
+            },
+
+            // 编码PCM数据为Opus
+            encode: function (pcmData) {
+                if (!this.encoderPtr) {
+                    if (!this.init()) {
+                        return null;
+                    }
+                }
+
+                try {
+                    const mod = this.module;
+
+                    // 为PCM数据分配内存
+                    const pcmPtr = mod._malloc(pcmData.length * 2); // 2字节/int16
+
+                    // 将PCM数据复制到HEAP
+                    for (let i = 0; i < pcmData.length; i++) {
+                        mod.HEAP16[(pcmPtr >> 1) + i] = pcmData[i];
+                    }
+
+                    // 为输出分配内存
+                    const outPtr = mod._malloc(this.maxPacketSize);
+
+                    // 进行编码
+                    const encodedLen = mod._opus_encode(
+                        this.encoderPtr,
+                        pcmPtr,
+                        this.frameSize,
+                        outPtr,
+                        this.maxPacketSize
+                    );
+
+                    if (encodedLen < 0) {
+                        throw new Error(`Opus编码失败: ${encodedLen}`);
+                    }
+
+                    // 复制编码后的数据
+                    const opusData = new Uint8Array(encodedLen);
+                    for (let i = 0; i < encodedLen; i++) {
+                        opusData[i] = mod.HEAPU8[outPtr + i];
+                    }
+
+                    // 释放内存
+                    mod._free(pcmPtr);
+                    mod._free(outPtr);
+
+                    return opusData;
+                } catch (error) {
+                    console.log(`Opus编码出错: ${error.message}`, 'error');
+                    return null;
+                }
+            },
+
+            // 销毁编码器
+            destroy: function () {
+                if (this.encoderPtr) {
+                    this.module._free(this.encoderPtr);
+                    this.encoderPtr = null;
+                }
+            }
+        };
+
+        opusEncoder.init();
+        return opusEncoder;
+    } catch (error) {
+        console.log(`创建Opus编码器失败: ${error.message}`, 'error');
+        return false;
+    }
+}

package/src/utils/ota-connector.js

@@ -0,0 +1,115 @@
+// WebSocket 连接
+export async function webSocketConnect(otaUrl, config) {
+
+    if (!validateConfig(config)) {
+        return;
+    }
+
+    // 发送OTA请求并获取返回的websocket信息
+    const otaResult = await sendOTA(otaUrl, config);
+    if (!otaResult) {
+        console.log('无法从OTA服务器获取信息', 'error');
+        return;
+    }
+
+    // 从OTA响应中提取websocket信息
+    const { websocket } = otaResult;
+    if (!websocket || !websocket.url) {
+        console.log('OTA响应中缺少websocket信息', 'error');
+        return;
+    }
+
+    // 使用OTA返回的websocket URL
+    let connUrl = new URL(websocket.url);
+
+    // 添加token参数（从OTA响应中获取）
+    if (websocket.token) {
+        if (websocket.token.startsWith("Bearer ")) {
+            connUrl.searchParams.append('authorization', websocket.token);
+        } else {
+            connUrl.searchParams.append('authorization', 'Bearer ' + websocket.token);
+        }
+    }
+
+    // 添加认证参数（保持原有逻辑）
+    connUrl.searchParams.append('device-id', config.deviceId);
+    connUrl.searchParams.append('client-id', config.clientId);
+
+    const wsurl = connUrl.toString()
+
+    console.log(`正在连接: ${wsurl}`, 'info');
+
+    return new WebSocket(connUrl.toString());
+}
+
+// 验证配置
+function validateConfig(config) {
+    if (!config.deviceMac) {
+        console.log('设备MAC地址不能为空', 'error');
+        return false;
+    }
+    if (!config.clientId) {
+        console.log('客户端ID不能为空', 'error');
+        return false;
+    }
+    return true;
+}
+
+// 判断wsUrl路径是否存在错误
+function validateWsUrl(wsUrl) {
+    if (wsUrl === '') return false;
+    // 检查URL格式
+    if (!wsUrl.startsWith('ws://') && !wsUrl.startsWith('wss://')) {
+        console.log('URL格式错误，必须以ws://或wss://开头', 'error');
+        return false;
+    }
+    return true
+}
+
+
+// OTA发送请求，验证状态，并返回响应数据
+async function sendOTA(otaUrl, config) {
+    try {
+        const res = await fetch(otaUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Device-Id': config.deviceId,
+                'Client-Id': config.clientId
+            },
+            body: JSON.stringify({
+                version: 0,
+                uuid: '',
+                application: {
+                    name: 'xiaozhi-web-test',
+                    version: '1.0.0',
+                    compile_time: '2025-04-16 10:00:00',
+                    idf_version: '4.4.3',
+                    elf_sha256: '1234567890abcdef1234567890abcdef1234567890abcdef'
+                },
+                ota: { label: 'xiaozhi-web-test' },
+                board: {
+                    type: 'xiaozhi-web-test',
+                    ssid: 'xiaozhi-web-test',
+                    rssi: 0,
+                    channel: 0,
+                    ip: '192.168.1.1',
+                    mac: config.deviceMac
+                },
+                flash_size: 0,
+                minimum_free_heap_size: 0,
+                mac_address: config.deviceMac,
+                chip_model_name: '',
+                chip_info: { model: 0, cores: 0, revision: 0, features: 0 },
+                partition_table: [{ label: '', type: 0, subtype: 0, address: 0, size: 0 }]
+            })
+        });
+
+        if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+
+        const result = await res.json();
+        return result; // 返回完整的响应数据
+    } catch (err) {
+        return null; // 失败返回null
+    }
+}

package/src/utils/player.js

@@ -0,0 +1,262 @@
+// 音频播放模块
+import BlockingQueue from "./blocking-queue.js";
+import { createStreamingContext } from "./stream-context.js";
+
+// 音频播放器类
+export class AudioPlayer {
+  constructor() {
+    // 音频参数
+    this.SAMPLE_RATE = 16000;
+    this.CHANNELS = 1;
+    this.FRAME_SIZE = 960;
+    this.MIN_AUDIO_DURATION = 0.12;
+
+    // 状态
+    this.audioContext = null;
+    this.opusDecoder = null;
+    this.streamingContext = null;
+    this.queue = new BlockingQueue();
+    this.isPlaying = false;
+  }
+
+  // 获取或创建AudioContext
+  getAudioContext() {
+    if (!this.audioContext) {
+      this.audioContext = new (window.AudioContext ||
+        window.webkitAudioContext)({
+        sampleRate: this.SAMPLE_RATE,
+        latencyHint: "interactive",
+      });
+      console.log(
+        "创建音频上下文，采样率: " + this.SAMPLE_RATE + "Hz",
+        "debug"
+      );
+    }
+    return this.audioContext;
+  }
+
+  // 初始化Opus解码器
+  async initOpusDecoder() {
+    if (this.opusDecoder) return this.opusDecoder;
+
+    try {
+      if (typeof window.ModuleInstance === "undefined") {
+        if (typeof Module !== "undefined") {
+          window.ModuleInstance = Module;
+          console.log("使用全局Module作为ModuleInstance", "info");
+        } else {
+          throw new Error("Opus库未加载，ModuleInstance和Module对象都不存在");
+        }
+      }
+
+      const mod = window.ModuleInstance;
+
+      this.opusDecoder = {
+        channels: this.CHANNELS,
+        rate: this.SAMPLE_RATE,
+        frameSize: this.FRAME_SIZE,
+        module: mod,
+        decoderPtr: null,
+
+        init: function () {
+          if (this.decoderPtr) return true;
+
+          const decoderSize = mod._opus_decoder_get_size(this.channels);
+          console.log(`Opus解码器大小: ${decoderSize}字节`, "debug");
+
+          this.decoderPtr = mod._malloc(decoderSize);
+          if (!this.decoderPtr) {
+            throw new Error("无法分配解码器内存");
+          }
+
+          const err = mod._opus_decoder_init(
+            this.decoderPtr,
+            this.rate,
+            this.channels
+          );
+
+          if (err < 0) {
+            this.destroy();
+            throw new Error(`Opus解码器初始化失败: ${err}`);
+          }
+
+          console.log("Opus解码器初始化成功", "success");
+          return true;
+        },
+
+        decode: function (opusData) {
+          if (!this.decoderPtr) {
+            if (!this.init()) {
+              throw new Error("解码器未初始化且无法初始化");
+            }
+          }
+
+          try {
+            const mod = this.module;
+
+            const opusPtr = mod._malloc(opusData.length);
+            mod.HEAPU8.set(opusData, opusPtr);
+
+            const pcmPtr = mod._malloc(this.frameSize * 2);
+
+            const decodedSamples = mod._opus_decode(
+              this.decoderPtr,
+              opusPtr,
+              opusData.length,
+              pcmPtr,
+              this.frameSize,
+              0
+            );
+
+            if (decodedSamples < 0) {
+              mod._free(opusPtr);
+              mod._free(pcmPtr);
+              throw new Error(`Opus解码失败: ${decodedSamples}`);
+            }
+
+            const decodedData = new Int16Array(decodedSamples);
+            for (let i = 0; i < decodedSamples; i++) {
+              decodedData[i] = mod.HEAP16[(pcmPtr >> 1) + i];
+            }
+
+            mod._free(opusPtr);
+            mod._free(pcmPtr);
+
+            return decodedData;
+          } catch (error) {
+            console.log(`Opus解码错误: ${error.message}`, "error");
+            return new Int16Array(0);
+          }
+        },
+
+        destroy: function () {
+          if (this.decoderPtr) {
+            this.module._free(this.decoderPtr);
+            this.decoderPtr = null;
+          }
+        },
+      };
+
+      if (!this.opusDecoder.init()) {
+        throw new Error("Opus解码器初始化失败");
+      }
+
+      return this.opusDecoder;
+    } catch (error) {
+      console.log(`Opus解码器初始化失败: ${error.message}`, "error");
+      this.opusDecoder = null;
+      throw error;
+    }
+  }
+
+  // 启动音频缓冲
+  async startAudioBuffering() {
+    console.log("开始音频缓冲...", "info");
+
+    this.initOpusDecoder().catch((error) => {
+      console.log(`预初始化Opus解码器失败: ${error.message}`, "warning");
+    });
+
+    const timeout = 400;
+    while (true) {
+      const packets = await this.queue.dequeue(6, timeout, (count) => {
+        console.log(`缓冲超时，当前缓冲包数: ${count}，开始播放`, "info");
+      });
+      if (packets.length) {
+        console.log(`已缓冲 ${packets.length} 个音频包，开始播放`, "info");
+        this.streamingContext.pushAudioBuffer(packets);
+      }
+
+      while (true) {
+        const data = await this.queue.dequeue(99, 30);
+        if (data.length) {
+          this.streamingContext.pushAudioBuffer(data);
+        } else {
+          break;
+        }
+      }
+    }
+  }
+
+  // 播放已缓冲的音频
+  async playBufferedAudio() {
+    try {
+      this.audioContext = this.getAudioContext();
+
+      if (!this.opusDecoder) {
+        console.log("初始化Opus解码器...", "info");
+        try {
+          this.opusDecoder = await this.initOpusDecoder();
+          if (!this.opusDecoder) {
+            throw new Error("解码器初始化失败");
+          }
+          console.log("Opus解码器初始化成功", "success");
+        } catch (error) {
+          console.log("Opus解码器初始化失败: " + error.message, "error");
+          this.isPlaying = false;
+          return;
+        }
+      }
+
+      if (!this.streamingContext) {
+        this.streamingContext = createStreamingContext(
+          this.opusDecoder,
+          this.audioContext,
+          this.SAMPLE_RATE,
+          this.CHANNELS,
+          this.MIN_AUDIO_DURATION
+        );
+      }
+
+      this.streamingContext.decodeOpusFrames();
+      this.streamingContext.startPlaying();
+    } catch (error) {
+      console.log(`播放已缓冲的音频出错: ${error.message}`, "error");
+      this.isPlaying = false;
+      this.streamingContext = null;
+    }
+  }
+
+  // 添加音频数据到队列
+  enqueueAudioData(opusData) {
+    if (opusData.length > 0) {
+      this.queue.enqueue(opusData);
+    } else {
+      console.log("收到空音频数据帧，可能是结束标志", "warning");
+      if (this.isPlaying && this.streamingContext) {
+        this.streamingContext.endOfStream = true;
+      }
+    }
+  }
+
+  // 预加载解码器
+  async preload() {
+    console.log("预加载Opus解码器...", "info");
+    try {
+      await this.initOpusDecoder();
+      console.log("Opus解码器预加载成功", "success");
+    } catch (error) {
+      console.log(
+        `Opus解码器预加载失败: ${error.message}，将在需要时重试`,
+        "warning"
+      );
+    }
+  }
+
+  // 启动播放系统
+  async start() {
+    await this.preload();
+    this.playBufferedAudio();
+    this.startAudioBuffering();
+  }
+}
+
+// 创建单例
+let audioPlayerInstance = null;
+
+export function getAudioPlayer() {
+  if (!audioPlayerInstance) {
+    audioPlayerInstance = new AudioPlayer();
+  }
+  return audioPlayerInstance;
+}