语音合成 WebSocket (TTS)

import json
import os

import websocket

WS_URL = "wss://api.senseaudio.cn/ws/v1/t2a_v2"
API_KEY = os.getenv("SENSEAUDIO_API_KEY")
if not API_KEY:
  raise RuntimeError("Missing env: SENSEAUDIO_API_KEY")

output_file = open("output.mp3", "wb")

def on_open(ws):
  print("WebSocket 连接已建立")

def on_message(ws, message: str):
  resp = json.loads(message)
  event = resp.get("event")
  print("收到服务端事件:", event)

  if event == "connected_success":
    ws.send(json.dumps({
      "event": "task_start",
      "model": "senseaudio-tts-1.5-260319",
      "voice_setting": {"voice_id": "male_0004_a", "speed": 1.0, "vol": 1.0, "pitch": 0, "latex_read": False},
      "audio_setting": {"sample_rate": 32000, "bitrate": 128000, "format": "mp3", "channel": 1}
    }))
    return

  if event == "task_started":
    ws.send(json.dumps({"event": "task_continue", "text": "道可道，非常道。名可名，非常名。无名天地之始，有名万物之母。"}))
    ws.send(json.dumps({"event": "task_continue", "text": "故常无欲，以观其妙；常有欲，以观其徼。"}))
    ws.send(json.dumps({"event": "task_finish"}))
    return

  data = resp.get("data") or {}
  audio_hex = data.get("audio")
  if audio_hex:
    output_file.write(bytes.fromhex(audio_hex))

  if event in ("task_finished", "task_failed"):
    if event == "task_failed":
      print("任务失败:", (resp.get("base_resp") or {}).get("status_msg"))
    output_file.close(); ws.close()

def on_error(ws, err): print("WebSocket 错误:", err)
def on_close(ws, status_code, msg): print("WebSocket 连接已关闭:", status_code, msg)

ws = websocket.WebSocketApp(
  WS_URL,
  header=[f"Authorization: Bearer {API_KEY}", "Content-Type: application/json"],
  on_open=on_open, on_message=on_message, on_error=on_error, on_close=on_close,
)
ws.run_forever()

package main

import (
  "encoding/hex"
  "encoding/json"
  "log"
  "net/http"
  "os"

  "github.com/gorilla/websocket"
)

const wsURL = "wss://api.senseaudio.cn/ws/v1/t2a_v2"

func mustMarshal(v any) []byte { b, err := json.Marshal(v); if err != nil { panic(err) }; return b }

func main() {
  apiKey := os.Getenv("SENSEAUDIO_API_KEY")
  if apiKey == "" { log.Fatal("Missing env: SENSEAUDIO_API_KEY") }

  header := http.Header{}
  header.Set("Authorization", "Bearer "+apiKey)
  header.Set("Content-Type", "application/json")

  c, _, err := websocket.DefaultDialer.Dial(wsURL, header)
  if err != nil { log.Fatal("dial:", err) }
  defer c.Close()

  out, err := os.Create("output.mp3")
  if err != nil { log.Fatal(err) }
  defer out.Close()

  for {
    _, msg, err := c.ReadMessage()
    if err != nil { log.Fatal("read:", err) }
    var resp map[string]any
    if err := json.Unmarshal(msg, &resp); err != nil { log.Fatal(err) }

    event, _ := resp["event"].(string)
    log.Println("收到服务端事件:", event)

    switch event {
    case "connected_success":
      _ = c.WriteMessage(websocket.TextMessage, mustMarshal(map[string]any{
        "event": "task_start",
        "model": "senseaudio-tts-1.5-260319",
        "voice_setting": map[string]any{"voice_id": "male_0004_a", "speed": 1.0, "vol": 1.0, "pitch": 0, "latex_read": false},
        "audio_setting": map[string]any{"sample_rate": 32000, "bitrate": 128000, "format": "mp3", "channel": 1},
      }))
    case "task_started":
      _ = c.WriteMessage(websocket.TextMessage, mustMarshal(map[string]any{"event": "task_continue", "text": "道可道，非常道。名可名，非常名。无名天地之始，有名万物之母。"}))
      _ = c.WriteMessage(websocket.TextMessage, mustMarshal(map[string]any{"event": "task_continue", "text": "故常无欲，以观其妙；常有欲，以观其徼。"}))
      _ = c.WriteMessage(websocket.TextMessage, mustMarshal(map[string]any{"event": "task_finish"}))
    case "task_failed", "task_finished":
      if event == "task_failed" {
        if baseResp, ok := resp["base_resp"].(map[string]any); ok {
          if msg, ok := baseResp["status_msg"].(string); ok { log.Println("任务失败:", msg) }
        }
      }
      return
    }

    if data, ok := resp["data"].(map[string]any); ok {
      if audioHex, ok := data["audio"].(string); ok && audioHex != "" {
        b, err := hex.DecodeString(audioHex)
        if err != nil { log.Fatal(err) }
        if _, err := out.Write(b); err != nil { log.Fatal(err) }
      }
    }
  }
}

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import okhttp3.*;
import okio.ByteString;

import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.Map;

public class SenseAudioTtsWsExample {
  private static final String WS_URL = "wss://api.senseaudio.cn/ws/v1/t2a_v2";

  public static void main(String[] args) throws Exception {
    String apiKey = System.getenv("SENSEAUDIO_API_KEY");
    if (apiKey == null || apiKey.isEmpty()) throw new RuntimeException("Missing env: SENSEAUDIO_API_KEY");

    OkHttpClient client = new OkHttpClient();
    ObjectMapper mapper = new ObjectMapper();

    Request request = new Request.Builder()
      .url(WS_URL)
      .addHeader("Authorization", "Bearer " + apiKey)
      .addHeader("Content-Type", "application/json")
      .build();

    FileOutputStream out = new FileOutputStream("output.mp3");

    client.newWebSocket(request, new WebSocketListener() {
      @Override public void onOpen(WebSocket webSocket, Response response) { System.out.println("WebSocket 连接已建立"); }

      @Override public void onMessage(WebSocket webSocket, String text) {
        try {
          JsonNode resp = mapper.readTree(text);
          String event = resp.path("event").asText();
          System.out.println("收到服务端事件: " + event);

          if ("connected_success".equals(event)) {
            Map<String, Object> payload = new HashMap<>();
            payload.put("event", "task_start");
            payload.put("model", "senseaudio-tts-1.5-260319");

            Map<String, Object> voice = new HashMap<>();
            voice.put("voice_id", "male_0004_a"); voice.put("speed", 1.0); voice.put("vol", 1.0);
            voice.put("pitch", 0); voice.put("latex_read", false);
            payload.put("voice_setting", voice);

            Map<String, Object> audio = new HashMap<>();
            audio.put("sample_rate", 32000); audio.put("bitrate", 128000);
            audio.put("format", "mp3"); audio.put("channel", 1);
            payload.put("audio_setting", audio);

            webSocket.send(mapper.writeValueAsString(payload));
            return;
          }

          if ("task_started".equals(event)) {
            webSocket.send(mapper.writeValueAsString(Map.of("event", "task_continue", "text", "道可道，非常道。名可名，非常名。无名天地之始，有名万物之母。")));
            webSocket.send(mapper.writeValueAsString(Map.of("event", "task_continue", "text", "故常无欲，以观其妙；常有欲，以观其徼。")));
            webSocket.send(mapper.writeValueAsString(Map.of("event", "task_finish")));
            return;
          }

          JsonNode audioHex = resp.path("data").path("audio");
          if (!audioHex.isMissingNode() && !audioHex.isNull()) {
            byte[] bytes = ByteString.decodeHex(audioHex.asText()).toByteArray();
            out.write(bytes);
          }

          if ("task_finished".equals(event) || "task_failed".equals(event)) {
            if ("task_failed".equals(event)) System.err.println("任务失败: " + resp.path("base_resp").path("status_msg").asText());
            out.close(); webSocket.close(1000, "done");
          }
        } catch (Exception e) { e.printStackTrace(); webSocket.close(1001, "error"); }
      }

      @Override public void onFailure(WebSocket webSocket, Throwable t, Response response) {
        t.printStackTrace();
        try { out.close(); } catch (Exception ignored) {}
      }
    });

    Thread.sleep(60_000);
    client.dispatcher().executorService().shutdown();
  }
}