语音合成 HTTP 流式 (TTS-SSE)

curl -X POST https://api.senseaudio.cn/v1/t2a_v2 \
  -H "Authorization: Bearer $SENSEAUDIO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "senseaudio-tts-1.5-260319",
    "text": "这是一个流式输出的例子。",
    "stream": true,
    "voice_setting": {
      "voice_id": "male_0004_a",
      "latex_read": false
    },
    "stream_options": {
      "exclude_aggregated_audio": true
    }
  }'

import requests
import json

API_URL = "https://api.senseaudio.cn/v1/t2a_v2"
HEADERS = {
    "Authorization": "Bearer SENSEAUDIO_API_KEY",
    "Content-Type": "application/json"
}

def tts_stream():
    payload = {
        "model": "senseaudio-tts-1.5-260319",
        "text": "这是一个流式输出的例子。",
        "stream": True,
        "voice_setting": {
            "voice_id": "male_0004_a",
            "latex_read": False
        },
        "stream_options": {
            "exclude_aggregated_audio": True
        }
    }
    with requests.post(API_URL, json=payload, headers=HEADERS, stream=True) as r:
        with open("stream_output.mp3", "wb") as f:
            for line in r.iter_lines():
                if line:
                    line_str = line.decode('utf-8')
                    if line_str.startswith("data: "):
                        line_str = line_str[6:]
                    resp = json.loads(line_str)
                    if "data" in resp and "audio" in resp["data"]:
                        f.write(bytes.fromhex(resp["data"]["audio"]))
        print("流式合成完成")

if __name__ == "__main__":
    tts_stream()

const axios = require('axios');
const fs = require('fs');

const API_URL = 'https://api.senseaudio.cn/v1/t2a_v2';
const HEADERS = {
    'Authorization': 'Bearer SENSEAUDIO_API_KEY',
    'Content-Type': 'application/json'
};

async function ttsStream() {
    try {
        const payload = {
            model: 'senseaudio-tts-1.5-260319',
            text: '这是一个流式输出的例子。',
            stream: true,
            voice_setting: {
                voice_id: 'male_0004_a',
                latex_read: false
            },
            stream_options: {
                exclude_aggregated_audio: true
            }
        };

        const res = await axios.post(API_URL, payload, {
            headers: HEADERS,
            responseType: 'stream'
        });

        const writeStream = fs.createWriteStream('stream_output.mp3');

        res.data.on('data', (chunk) => {
            const lines = chunk.toString().split('\n');
            for (const line of lines) {
                if (line.startsWith('data: ')) {
                    try {
                        const json = JSON.parse(line.slice(6));
                        if (json.data && json.data.audio) {
                            writeStream.write(Buffer.from(json.data.audio, 'hex'));
                        }
                    } catch (e) {}
                }
            }
        });

        res.data.on('end', () => {
            writeStream.end();
            console.log('流式合成完成');
        });
    } catch (err) {
        console.error('请求异常:', err.message);
    }
}

ttsStream();

package main

import (
    "bufio"
    "bytes"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    "strings"
)

const (
    APIURL             = "https://api.senseaudio.cn/v1/t2a_v2"
    SENSEAUDIO_API_KEY = "SENSEAUDIO_API_KEY"
)

type TTSRequest struct {
    Model         string        `json:"model"`
    Text          string        `json:"text"`
    Stream        bool          `json:"stream"`
    VoiceSetting  VoiceSetting  `json:"voice_setting"`
    StreamOptions StreamOptions `json:"stream_options"`
}

type StreamOptions struct {
    ExcludeAggregatedAudio bool `json:"exclude_aggregated_audio"`
}

type VoiceSetting struct {
    VoiceID   string `json:"voice_id"`
    LatexRead bool   `json:"latex_read"`
}

type SSEResponse struct {
    Data struct {
        Audio  string `json:"audio"`
        Status int    `json:"status"`
    } `json:"data"`
    BaseResp struct {
        StatusCode    int    `json:"status_code"`
        StatusMessage string `json:"status_msg"`
    } `json:"base_resp"`
}

func main() {
    payload := TTSRequest{
        Model:  "senseaudio-tts-1.5-260319",
        Text:   "这是一个流式输出的例子。",
        Stream: true,
        VoiceSetting: VoiceSetting{
            VoiceID:   "male_0004_a",
            LatexRead: false,
        },
        StreamOptions: StreamOptions{
            ExcludeAggregatedAudio: true,
        },
    }

    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", APIURL, bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer "+SENSEAUDIO_API_KEY)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("请求失败:", err)
        return
    }
    defer resp.Body.Close()

    file, _ := os.Create("stream_output.mp3")
    defer file.Close()

    scanner := bufio.NewScanner(resp.Body)
    for scanner.Scan() {
        line := scanner.Text()
        if strings.HasPrefix(line, "data: ") {
            var result SSEResponse
            json.Unmarshal([]byte(line[6:]), &result)
            if result.Data.Audio != "" {
                audioData, _ := hex.DecodeString(result.Data.Audio)
                file.Write(audioData)
            }
        }
    }
    fmt.Println("流式合成完成")
}

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import org.json.JSONObject;

public class SenseAudioTTSStream {
    private static final String API_URL = "https://api.senseaudio.cn/v1/t2a_v2";
    private static final String SENSEAUDIO_API_KEY = "SENSEAUDIO_API_KEY";

    public static void main(String[] args) {
        try {
            JSONObject voiceSetting = new JSONObject();
            voiceSetting.put("voice_id", "male_0004_a");
            voiceSetting.put("latex_read", false);

            JSONObject payload = new JSONObject();
            payload.put("model", "senseaudio-tts-1.5-260319");
            payload.put("text", "这是一个流式输出的例子。");
            payload.put("stream", true);
            payload.put("voice_setting", voiceSetting);
            payload.put("stream_options", new JSONObject().put("exclude_aggregated_audio", true));

            URL url = new URL(API_URL);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Authorization", "Bearer " + SENSEAUDIO_API_KEY);
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setDoOutput(true);

            try (OutputStream os = conn.getOutputStream()) {
                byte[] input = payload.toString().getBytes("utf-8");
                os.write(input, 0, input.length);
            }

            try (BufferedReader br = new BufferedReader(
                    new InputStreamReader(conn.getInputStream(), "utf-8"));
                 FileOutputStream fos = new FileOutputStream("stream_output.mp3")) {

                String line;
                while ((line = br.readLine()) != null) {
                    if (line.startsWith("data: ")) {
                        String jsonStr = line.substring(6);
                        JSONObject result = new JSONObject(jsonStr);
                        if (result.has("data")) {
                            JSONObject data = result.getJSONObject("data");
                            if (data.has("audio")) {
                                String audioHex = data.getString("audio");
                                byte[] audioData = new byte[audioHex.length() / 2];
                                for (int i = 0; i < audioData.length; i++) {
                                    int index = i * 2;
                                    int val = Integer.parseInt(audioHex.substring(index, index + 2), 16);
                                    audioData[i] = (byte) val;
                                }
                                fos.write(audioData);
                            }
                        }
                    }
                }
                System.out.println("流式合成完成");
            }
        } catch (Exception e) {
            System.out.println("请求异常: " + e.getMessage());
            e.printStackTrace();
        }
    }
}