介绍 · 服务概览

{
  "code": 0,
  "data": {
    "task_id": "asr-1234567890abcdef"
  },
  "message": "task initialized successfully"
}

{
  "code": -1,
  "data": {
    "task_id": "asr-1234567890abcdef"
  },
  "message": "upload failed: TOS upload error"
}

{
  "code": 0,
  "data": {
    "task_id": "asr-1234567890abcdef"
  },
  "message": "task initialized successfully"
}

{
  "code": -1,
  "data": {
    "task_id": "asr-1234567890abcdef"
  },
  "message": "redis enqueue failed: Connection error"
}

// 或 URL 验证失败时：
{
  "code": -1,
  "message": "Invalid URL format: Missing scheme"
}

{
  "code": 0,
  "data": {
    "task_id": "asr-1234567890abcdef",
    "status": "PROCESSING",
    "file_hash": "abc123...",
    "audio_url": "https://example.com/audio.wav",
    "file_name": "会议录音.wav",
    "file_type": ".wav",
    "file_size": 1024000
  },
  "message": "success"
}

{
  "code": 0,
  "data": {
    "task_id": "asr-1234567890abcdef",
    "status": "SUCCESS",
    "text": "完整识别文本……",
    "utterances": [
      {
        "start_time": 0,
        "end_time": 2000,
        "text": "第一句话。",
        "speaker": "spk0"
      },
      {
        "start_time": 2000,
        "end_time": 5000,
        "text": "第二句话。",
        "speaker": "spk1"
      }
    ],
    "processing_time_ms": 18352,
    "audio_duration_ms": 60213,
    "sample_rate": 16000,
    "file_hash": "abc123...",
    "audio_url": "https://example.com/audio.wav",
    "file_name": "会议录音.wav",
    "file_type": ".wav",
    "file_size": 1024000,
    "created_at": "2024-01-01T10:00:00",
    "updated_at": "2024-01-01T10:00:30"
  },
  "message": "success"
}

{
  "code": -1,
  "message": "task not found"
}

// 或任务处理失败时：
{
  "code": 0,
  "data": {
    "task_id": "asr-1234567890abcdef",
    "status": "FAILED",
    "error_msg": "ASR processing failed: Model error",
    "file_hash": "abc123...",
    "audio_url": "https://example.com/audio.wav",
    "file_name": "会议录音.wav",
    "file_type": ".wav",
    "file_size": 1024000
  },
  "message": "success"
}

// 使用 Web Audio API 采集音频并发送
const audioContext = new AudioContext({ sampleRate: 16000 });
const mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
const source = audioContext.createMediaStreamSource(mediaStream);
const processor = audioContext.createScriptProcessor(4096, 1, 1);

processor.onaudioprocess = (e) => {
    if (ws.readyState === WebSocket.OPEN) {
        const inputData = e.inputBuffer.getChannelData(0);
        // 转换为 int16
        const int16Data = new Int16Array(inputData.length);
        for (let i = 0; i < inputData.length; i++) {
            int16Data[i] = Math.max(-32768, Math.min(32767, inputData[i] * 32768));
        }
        // 发送二进制数据
        ws.send(int16Data.buffer);
    }
};

source.connect(processor);
processor.connect(audioContext.destination);

// 建立 WebSocket 连接
const ws = new WebSocket('wss://fasr.shanghaijiyue.com/api/v1/asr/realtime');

ws.onopen = () => {
    console.log('WebSocket 连接已建立');
};

ws.onmessage = (event) => {
    // 处理服务端消息
    const message = JSON.parse(event.data);
    console.log('收到消息:', message);
};

ws.onerror = (error) => {
    console.error('WebSocket 错误:', error);
};

ws.onclose = () => {
    console.log('WebSocket 连接已关闭');
};

ws.onmessage = (event) => {
    let message;
    
    // 尝试解析消息（支持 MessagePack 或 JSON）
    try {
        if (event.data instanceof ArrayBuffer) {
            // 二进制数据，可能是 MessagePack
            // 如果没有 msgpack 库，转换为文本后解析 JSON
            message = JSON.parse(new TextDecoder().decode(event.data));
        } else {
            // 文本数据，直接解析 JSON
            message = JSON.parse(event.data);
        }
    } catch (e) {
        console.error('解析消息失败:', e);
        return;
    }
    
    const { status, text, connection_id, message: msg } = message;
    
    switch (status) {
        case 'connected':
            console.log('连接成功:', connection_id);
            break;
        case 'partial':
            console.log('[部分结果]', text);
            // 更新 UI 显示部分结果
            document.getElementById('result').textContent = text;
            break;
        case 'final':
            console.log('[最终结果]', text);
            // 更新 UI 显示最终结果
            document.getElementById('result').textContent = text;
            break;
        case 'error':
            console.error('错误:', msg);
            break;
        case 'timeout':
            console.warn('超时:', msg);
            break;
    }
};

// 获取麦克风权限并开始采集音频
async function startRecording() {
    try {
        // 获取麦克风权限
        const mediaStream = await navigator.mediaDevices.getUserMedia({
            audio: {
                sampleRate: 16000,
                channelCount: 1,
                echoCancellation: true,
                noiseSuppression: true
            }
        });
        
        // 创建音频上下文
        const audioContext = new AudioContext({ sampleRate: 16000 });
        const source = audioContext.createMediaStreamSource(mediaStream);
        
        // 创建音频处理节点
        const processor = audioContext.createScriptProcessor(4096, 1, 1);
        
        processor.onaudioprocess = (e) => {
            if (ws.readyState === WebSocket.OPEN) {
                const inputData = e.inputBuffer.getChannelData(0);
                
                // 转换为 int16
                const int16Data = new Int16Array(inputData.length);
                for (let i = 0; i < inputData.length; i++) {
                    int16Data[i] = Math.max(-32768, Math.min(32767, inputData[i] * 32768));
                }
                
                // 发送二进制音频数据
                ws.send(int16Data.buffer);
            }
        };
        
        source.connect(processor);
        processor.connect(audioContext.destination);
        
        console.log('开始录音');
    } catch (error) {
        console.error('启动录音失败:', error);
    }
}

// 连接成功后开始录音
ws.onopen = () => {
    console.log('WebSocket 连接已建立');
    startRecording();
};

class RealtimeASRClient {
    constructor(wsUrl) {
        this.wsUrl = wsUrl;
        this.ws = null;
        this.audioContext = null;
        this.mediaStream = null;
        this.processor = null;
        this.connectionId = null;
    }
    
    async connect() {
        return new Promise((resolve, reject) => {
            this.ws = new WebSocket(this.wsUrl);
            this.ws.onopen = () => resolve();
            this.ws.onmessage = (e) => this.handleMessage(e.data);
            this.ws.onerror = (e) => reject(e);
            this.ws.onclose = () => console.log('连接已关闭');
        });
    }
    
    handleMessage(data) {
        let msg = data instanceof ArrayBuffer 
            ? JSON.parse(new TextDecoder().decode(data))
            : JSON.parse(data);
        const { status, text, connection_id } = msg;
        if (status === 'connected') this.connectionId = connection_id;
        if (status === 'partial') this.onPartialResult(text);
        if (status === 'final') this.onFinalResult(text);
    }
    
    async startRecording() {
        this.mediaStream = await navigator.mediaDevices.getUserMedia({
            audio: { sampleRate: 16000, channelCount: 1 }
        });
        this.audioContext = new AudioContext({ sampleRate: 16000 });
        const source = this.audioContext.createMediaStreamSource(this.mediaStream);
        this.processor = this.audioContext.createScriptProcessor(4096, 1, 1);
        this.processor.onaudioprocess = (e) => {
            if (this.ws.readyState === WebSocket.OPEN) {
                const data = e.inputBuffer.getChannelData(0);
                const int16 = new Int16Array(data.length);
                for (let i = 0; i < data.length; i++) {
                    int16[i] = Math.max(-32768, Math.min(32767, data[i] * 32768));
                }
                this.ws.send(int16.buffer);
            }
        };
        source.connect(this.processor);
        this.processor.connect(this.audioContext.destination);
    }
    
    disconnect() {
        if (this.processor) this.processor.disconnect();
        if (this.audioContext) this.audioContext.close();
        if (this.mediaStream) this.mediaStream.getTracks().forEach(t => t.stop());
        if (this.ws) this.ws.close();
    }
    
    onPartialResult(text) { console.log('[部分]', text); }
    onFinalResult(text) { console.log('[最终]', text); }
}

// 使用
const client = new RealtimeASRClient('wss://fasr.shanghaijiyue.com/api/v1/asr/realtime');
client.connect().then(() => client.startRecording());