语音识别 WebSocket (ASR)

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"time"

	"github.com/gorilla/websocket"
)

const (
	SENSEAUDIO_API_KEY = "SENSEAUDIO_API_KEY"
	WS_URL             = "wss://api.senseaudio.cn/ws/v1/audio/transcriptions"
	AUDIO_FILE         = "test_audio_16k.pcm"
)

func main() {
	header := http.Header{}
	header.Add("Authorization", "Bearer "+SENSEAUDIO_API_KEY)

	log.Printf("Connecting to %s", WS_URL)
	c, _, err := websocket.DefaultDialer.Dial(WS_URL, header)
	if err != nil {
		log.Fatal("dial error:", err)
	}
	defer c.Close()

	// 1. 读取连接成功 msg
	readMessage(c)

	// 2. 发送 task_start
	startMsg := map[string]interface{}{
		"event": "task_start",
		"model": "senseaudio-asr-deepthink-1.5-260319",
		"audio_setting": map[string]interface{}{
			"sample_rate": 16000,
			"format":      "pcm",
			"channel":     1,
		},
	}
	if err := c.WriteJSON(startMsg); err != nil {
		log.Fatal("write startMsg error:", err)
	}
	fmt.Println("> Sent task_start")

	// 读取 task_started
	readMessage(c)

	// 3. 准备并发读取结果
	done := make(chan struct{})
	go func() {
		defer close(done)
		for {
			_, message, err := c.ReadMessage()
			if err != nil {
				if websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
					fmt.Println("< Connection closed normally")
					return
				}
				log.Println("read error:", err)
				return
			}
			fmt.Printf("< Received: %s\n", message)

			var msgMap map[string]interface{}
			if err := json.Unmarshal(message, &msgMap); err != nil {
				log.Println("json unmarshal error:", err)
				continue
			}
			if event, ok := msgMap["event"].(string); ok && event == "task_finished" {
				return
			}
		}
	}()

	// 4. 发送音频（100ms 分片）
	file, err := os.Open(AUDIO_FILE)
	if err != nil {
		log.Fatal("open audio file error:", err)
	}
	defer file.Close()

	const chunkSize = 3200
	buf := make([]byte, chunkSize)

	for {
		n, err := file.Read(buf)
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatal("read file error:", err)
		}

		if err := c.WriteMessage(websocket.BinaryMessage, buf[:n]); err != nil {
			log.Fatal("write message error:", err)
		}
		fmt.Printf("> Sent %d bytes audio data\n", n)

		// 模拟实时发送：100ms 的音频数据等待 100ms
		if n == chunkSize {
			time.Sleep(100 * time.Millisecond)
		}
	}

	// 5. 发送 task_finish
	if err := c.WriteJSON(map[string]string{"event": "task_finish"}); err != nil {
		log.Fatal("write task_finish error:", err)
	}

	// 6. 等待服务端处理完成并返回 task_finished
	<-done

	fmt.Println("> Sent task_finish")
	fmt.Println("All done!")
}

func readMessage(c *websocket.Conn) {
	_, message, err := c.ReadMessage()
	if err != nil {
		if websocket.IsCloseError(err, websocket.CloseNormalClosure, websocket.CloseGoingAway) {
			fmt.Println("< Connection closed")
			return
		}
		log.Fatal("read message error:", err)
	}
	fmt.Printf("< Received: %s\n", message)
}

const WebSocket = require('ws');
const fs = require('fs');

const SENSEAUDIO_API_KEY = "SENSEAUDIO_API_KEY";
const WS_URL = "wss://api.senseaudio.cn/ws/v1/audio/transcriptions";
const AUDIO_FILE = "test_audio_16k.pcm";

const ws = new WebSocket(WS_URL, {
  headers: {
    Authorization: `Bearer ${SENSEAUDIO_API_KEY}`,
  },
});

ws.on('open', () => console.log('Connected'));

ws.on('message', (data, isBinary) => {
  if (isBinary) return;

  const msg = JSON.parse(data.toString());
  console.log('< Received:', msg.event);

  if (msg.event === 'connected_success') {
    const startMsg = {
      event: 'task_start',
      model: 'senseaudio-asr-deepthink-1.5-260319',
      audio_setting: { sample_rate: 16000, format: 'pcm', channel: 1 },
    };
    ws.send(JSON.stringify(startMsg));
    console.log('> Sent task_start');
  } else if (msg.event === 'task_started') {
    streamAudio();
  } else if (msg.event === 'result_final') {
    console.log('  Result:', msg.data.text);
  } else if (msg.event === 'task_finished') {
    process.exit(0);
  }
});

function streamAudio() {
  const stream = fs.createReadStream(AUDIO_FILE, { highWaterMark: 3200 });
  let processing = false;

  stream.on('data', (chunk) => {
    stream.pause();
    processing = true;
    ws.send(chunk);

    setTimeout(() => {
      processing = false;
      stream.resume();
    }, 100);
  });

  stream.on('end', () => {
    const checkAndFinish = () => {
      if (!processing) {
        ws.send(JSON.stringify({ event: 'task_finish' }));
        console.log('> Sent task_finish');
      } else {
        setTimeout(checkAndFinish, 50);
      }
    };
    checkAndFinish();
  });
}