Alibaba Cloud Model Studio:音声合成マークアップ言語 (SSML)

非ストリーミング呼び出し

import com.alibaba.dashscope.audio.ttsv2.SpeechSynthesisParam;
import com.alibaba.dashscope.audio.ttsv2.SpeechSynthesizer;
import com.alibaba.dashscope.utils.Constants;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

/**
 * SSML の特徴に関する注意：
 *     1. SSML は、非ストリーミング呼び出しと単方向ストリーミング呼び出しでのみサポートされます。
 *     2. SSML は、cosyvoice-v3-flash、cosyvoice-v3-plus、および cosyvoice-v2 モデルのクローン音声、
 *        および音声リストで SSML 対応とマークされたシステム音声 (例：cosyvoice-v3-flash の longanyang 音声) でのみサポートされます。
 */
public class Main {
    private static String model = "cosyvoice-v3-flash";
    private static String voice = "longanyang";

    public static void main(String[] args) {
        // 北京リージョンのモデルを使用する場合は、URL を wss://dashscope.aliyuncs.com/api-ws/v1/inference に置き換えてください
        Constants.baseWebsocketApiUrl = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference";
        streamAudioDataToSpeaker();
        System.exit(0);
    }

    public static void streamAudioDataToSpeaker() {
        SpeechSynthesisParam param =
                SpeechSynthesisParam.builder()
                        // シンガポールリージョンと北京リージョンの API キーは異なります。API キーの取得方法については、https://www.alibabacloud.com/help/model-studio/get-api-key をご参照ください
                        // 環境変数を設定していない場合は、次の行を .apiKey("sk-xxx") に置き換えてください
                        .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                        .model(model)
                        .voice(voice)
                        .build();

        SpeechSynthesizer synthesizer = new SpeechSynthesizer(param, null);
        ByteBuffer audio = null;
        try {
            // 非ストリーミング呼び出し。音声が返されるまでブロックします
            // 特殊文字をエスケープします
            audio = synthesizer.call("<speak rate=\"2\">My speaking rate is faster than a normal person's.</speak>");
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            // タスク終了後に WebSocket 接続を閉じます
            synthesizer.getDuplexApi().close(1000, "bye");
        }
        if (audio != null) {
            // 音声データを "output.mp3" という名前のローカルファイルに保存します
            File file = new File("output.mp3");
            try (FileOutputStream fos = new FileOutputStream(file)) {
                fos.write(audio.array());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        // 先頭パケットのレイテンシには、WebSocket 接続の確立に必要な時間が含まれます
        System.out.println(
                "[Metric] Request ID: "
                        + synthesizer.getLastRequestId()
                        + ", First packet latency (ms): "
                        + synthesizer.getFirstPackageDelay());
    }
}

単方向ストリーミング呼び出し

import com.alibaba.dashscope.audio.tts.SpeechSynthesisResult;
import com.alibaba.dashscope.audio.ttsv2.SpeechSynthesisAudioFormat;
import com.alibaba.dashscope.audio.ttsv2.SpeechSynthesisParam;
import com.alibaba.dashscope.audio.ttsv2.SpeechSynthesizer;
import com.alibaba.dashscope.common.ResultCallback;
import com.alibaba.dashscope.utils.Constants;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;

/**
 * SSML の特徴に関する注意：
 *     1. SSML は、非ストリーミング呼び出しと単方向ストリーミング呼び出しでのみサポートされます。
 *     2. SSML は、cosyvoice-v3-flash、cosyvoice-v3-plus、および cosyvoice-v2 モデルのクローン音声、
 *        および音声リストで SSML 対応とマークされたシステム音声 (例：cosyvoice-v3-flash の longanyang 音声) でのみサポートされます。
 */
public class Main {
    private static String model = "cosyvoice-v3-flash";
    private static String voice = "longanyang";

    public static void main(String[] args) {
        // 北京リージョンのモデルを使用する場合は、URL を wss://dashscope.aliyuncs.com/api-ws/v1/inference に置き換えてください
        Constants.baseWebsocketApiUrl = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference";
        streamAudioDataToSpeaker();
        System.out.println("Audio saved to output.mp3");
        System.exit(0);
    }

    public static void streamAudioDataToSpeaker() {
        CountDownLatch latch = new CountDownLatch(1);
        final FileOutputStream[] fileOutputStream = new FileOutputStream[1];

        try {
            fileOutputStream[0] = new FileOutputStream("output.mp3");
        } catch (IOException e) {
            System.err.println("Failed to create output file: " + e.getMessage());
            return;
        }

        // ResultCallback インターフェイスを実装します
        ResultCallback<SpeechSynthesisResult> callback = new ResultCallback<SpeechSynthesisResult>() {
            @Override
            public void onEvent(SpeechSynthesisResult result) {
                if (result.getAudioFrame() != null) {
                    // 音声データをローカルファイルに書き込みます
                    try {
                        byte[] audioData = result.getAudioFrame().array();
                        fileOutputStream[0].write(audioData);
                        fileOutputStream[0].flush();
                    } catch (IOException e) {
                        System.err.println("Failed to write audio data: " + e.getMessage());
                    }
                }
            }

            @Override
            public void onComplete() {
                System.out.println("Received Complete; speech synthesis finished");
                closeFileOutputStream(fileOutputStream[0]);
                latch.countDown();
            }

            @Override
            public void onError(Exception e) {
                System.out.println("Error occurred: " + e.toString());
                closeFileOutputStream(fileOutputStream[0]);
                latch.countDown();
            }
        };

        SpeechSynthesisParam param =
                SpeechSynthesisParam.builder()
                        // シンガポールリージョンと北京リージョンの API キーは異なります。API キーの取得方法については、https://www.alibabacloud.com/help/model-studio/get-api-key をご参照ください
                        // 環境変数を設定していない場合は、次の行を .apiKey("sk-xxx") に置き換えてください
                        .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                        .model(model)
                        .voice(voice)
                        .format(SpeechSynthesisAudioFormat.MP3_22050HZ_MONO_256KBPS)
                        .build();

        SpeechSynthesizer synthesizer = new SpeechSynthesizer(param, callback);

        try {
            // 単方向ストリーミング呼び出し。すぐに null を返します (結果はコールバックを通じて非同期に配信されます)
            // 特殊文字をエスケープします
            synthesizer.call("<speak rate=\"2\">My speaking rate is faster than a normal person's.</speak>");
            // 合成が完了するのを待ちます
            latch.await();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            // タスク終了後に WebSocket 接続を閉じます
            try {
                synthesizer.getDuplexApi().close(1000, "bye");
            } catch (Exception e) {
                System.err.println("Failed to close WebSocket connection: " + e.getMessage());
            }

            // ファイルストリームが閉じられていることを確認します
            closeFileOutputStream(fileOutputStream[0]);
        }

        // 先頭パケットのレイテンシには、WebSocket 接続の確立に必要な時間が含まれます
        System.out.println(
                "[Metric] Request ID: "
                        + synthesizer.getLastRequestId()
                        + ", First packet latency (ms): "
                        + synthesizer.getFirstPackageDelay());
    }

    private static void closeFileOutputStream(FileOutputStream fileOutputStream) {
        try {
            if (fileOutputStream != null) {
                fileOutputStream.close();
            }
        } catch (IOException e) {
            System.err.println("Failed to close file stream: " + e.getMessage());
        }
    }
}

非ストリーミング呼び出し

# coding=utf-8
# SSML の特徴に関する注意：
#     1. SSML は、非ストリーミング呼び出しと単方向ストリーミング呼び出しでのみサポートされます。
#     2. SSML は、cosyvoice-v3-flash、cosyvoice-v3-plus、および cosyvoice-v2 モデルのクローン音声、
#        および音声リストで SSML 対応とマークされたシステム音声 (例：cosyvoice-v3-flash の longanyang 音声) でのみサポートされます。

import dashscope
from dashscope.audio.tts_v2 import *
import os

# シンガポールリージョンと北京リージョンの API キーは異なります。API キーの取得方法については、https://www.alibabacloud.com/help/model-studio/get-api-key をご参照ください
# 環境変数を設定していない場合は、次の行を dashscope.api_key = "sk-xxx" に置き換えてください
dashscope.api_key = os.environ.get('DASHSCOPE_API_KEY')

# 北京リージョンのモデルを使用する場合は、URL を wss://dashscope.aliyuncs.com/api-ws/v1/inference に置き換えてください
dashscope.base_websocket_api_url='wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference'

# モデル
model = "cosyvoice-v3-flash"
# 音声
voice = "longanyang"

# SpeechSynthesizer をインスタンス化し、モデル、音声、その他のリクエストパラメーターをコンストラクターに渡します
synthesizer = SpeechSynthesizer(model=model, voice=voice)
# 非ストリーミング呼び出し。音声が返されるまでブロックします
# 特殊文字をエスケープします
audio = synthesizer.call("<speak rate=\"2\">My speaking rate is faster than a normal person's.</speak>")

# 音声をローカルに保存します
with open('output.mp3', 'wb') as f:
    f.write(audio)

# 先頭パケットのレイテンシには、WebSocket 接続の確立に必要な時間が含まれます
print('[Metric] Request ID: {}, First packet latency: {} ms'.format(
    synthesizer.get_last_request_id(),
    synthesizer.get_first_package_delay()))

単方向ストリーミング呼び出し

# coding=utf-8
# SSML の特徴に関する注意：
#     1. SSML は、非ストリーミング呼び出しと単方向ストリーミング呼び出しでのみサポートされます。
#     2. SSML は、cosyvoice-v3-flash、cosyvoice-v3-plus、および cosyvoice-v2 モデルのクローン音声、
#        および音声リストで SSML 対応とマークされたシステム音声 (例：cosyvoice-v3-flash の longanyang 音声) でのみサポートされます。

import dashscope
from dashscope.audio.tts_v2 import *
import os
from datetime import datetime

def get_timestamp():
    now = datetime.now()
    formatted_timestamp = now.strftime("[%Y-%m-%d %H:%M:%S.%f]")
    return formatted_timestamp

# シンガポールリージョンと北京リージョンの API キーは異なります。API キーの取得方法については、https://www.alibabacloud.com/help/model-studio/get-api-key をご参照ください
# 環境変数を設定していない場合は、次の行を dashscope.api_key = "sk-xxx" に置き換えてください
dashscope.api_key = os.environ.get('DASHSCOPE_API_KEY')

# 北京リージョンのモデルを使用する場合は、URL を wss://dashscope.aliyuncs.com/api-ws/v1/inference に置き換えてください
dashscope.base_websocket_api_url='wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference'

# モデル
model = "cosyvoice-v3-flash"
# 音声
voice = "longanyang"

# コールバックインターフェイスを定義します
class Callback(ResultCallback):
    _player = None
    _stream = None

    def on_open(self):
        # 音声データを書き込むための出力ファイルを開きます
        self.file = open("output.mp3", "wb")
        print("Connection established: " + get_timestamp())

    def on_complete(self):
        print("Speech synthesis completed; all results received: " + get_timestamp())
        if hasattr(self, 'file') and self.file:
            self.file.close()
        self
        # 先頭パケットのレイテンシには、WebSocket 接続の確立に必要な時間が含まれます
        print('[Metric] Request ID: {}, First packet latency: {} ms'.format(
            self.synthesizer.get_last_request_id(),
            self.synthesizer.get_first_package_delay()))

    def on_error(self, message: str):
        print(f"Speech synthesis error: {message}")
        if hasattr(self, 'file') and self.file:
            self.file.close()

    def on_close(self):
        print("Connection closed: " + get_timestamp())
        if hasattr(self, 'file') and self.file:
            self.file.close()

    def on_event(self, message):
        pass

    def on_data(self, data: bytes) -> None:
        print(get_timestamp() + " Binary audio length: " + str(len(data)))
        # 音声データをファイルに書き込みます
        self.file.write(data)

callback = Callback()

# SpeechSynthesizer をインスタンス化し、モデル、音声、その他のリクエストパラメーターをコンストラクターに渡します
synthesizer = SpeechSynthesizer(
    model=model,
    voice=voice,
    callback=callback,
)

# on_complete で使用するために、シンセサイザーインスタンスをコールバックに割り当てます
callback.synthesizer = synthesizer

# 単方向ストリーミング呼び出し。合成するテキストを送信し、コールバックの on_data メソッドを介してリアルタイムでバイナリ音声を受信します
# 特殊文字をエスケープします
synthesizer.call("<speak rate=\"2\">My speaking rate is faster than a normal person's.</speak>")

Go

// SSML の特徴に関する注意：
//     1. run-task コマンドで enable_ssml パラメーターを true に設定して SSML を有効にします。
//     2. continue-task コマンドを使用して SSML テキストを送信します。このコマンドは一度しか送信できません。
//     3. SSML は、cosyvoice-v3-flash、cosyvoice-v3-plus、および cosyvoice-v2 モデルのクローン音声、
//        および音声リストで SSML 対応とマークされたシステム音声 (例：cosyvoice-v3-flash の longanyang 音声) でのみサポートされます。

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    "strings"
    "time"

    "github.com/google/uuid"
    "github.com/gorilla/websocket"
)

const (
    // 北京リージョンのモデルを使用する場合は、URL を wss://dashscope.aliyuncs.com/api-ws/v1/inference/ に置き換えてください
    wsURL      = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/"
    outputFile = "output.mp3"
)

func main() {
    // シンガポールリージョンと北京リージョンの API キーは異なります。API キーの取得方法については、https://www.alibabacloud.com/help/model-studio/get-api-key をご参照ください
    // 環境変数を設定していない場合は、次の行を apiKey := "sk-xxx" に置き換えてください
    apiKey := os.Getenv("DASHSCOPE_API_KEY")

    // 出力ファイルをクリアします
    os.Remove(outputFile)
    os.Create(outputFile)

    // WebSocket に接続します
    header := make(http.Header)
    header.Add("X-DashScope-DataInspection", "enable")
    header.Add("Authorization", fmt.Sprintf("bearer %s", apiKey))

    conn, resp, err := websocket.DefaultDialer.Dial(wsURL, header)
    if err != nil {
        if resp != nil {
            fmt.Printf("Connection failed. HTTP status code: %d\n", resp.StatusCode)
        }
        fmt.Println("Connection failed:", err)
        return
    }
    defer conn.Close()

    // タスク ID を生成します
    taskID := uuid.New().String()
    fmt.Printf("Generated task ID: %s\n", taskID)

    // run-task コマンドを送信します
    runTaskCmd := map[string]interface{}{
        "header": map[string]interface{}{
            "action":    "run-task",
            "task_id":   taskID,
            "streaming": "duplex",
        },
        "payload": map[string]interface{}{
            "task_group": "audio",
            "task":       "tts",
            "function":   "SpeechSynthesizer",
            "model":      "cosyvoice-v3-flash",
            "parameters": map[string]interface{}{
                "text_type":   "PlainText",
                "voice":       "longanyang",
                "format":      "mp3",
                "sample_rate": 22050,
                "volume":      50,
                "rate":        1,
                "pitch":       1,
                // enable_ssml が true に設定されている場合、continue-task コマンドは一度しか送信できません。
                // そうしないと、「Text request limit violated, expected 1.」というエラーが表示されます。
                "enable_ssml": true,
            },
            "input": map[string]interface{}{},
        },
    }

    runTaskJSON, _ := json.Marshal(runTaskCmd)
    fmt.Printf("Sending run-task command: %s\n", string(runTaskJSON))

    err = conn.WriteMessage(websocket.TextMessage, runTaskJSON)
    if err != nil {
        fmt.Println("Failed to send run-task:", err)
        return
    }

    textSent := false

    // メッセージを処理します
    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            fmt.Println("Failed to read message:", err)
            break
        }

        // バイナリメッセージを処理します
        if messageType == websocket.BinaryMessage {
            fmt.Printf("Received binary message, length: %d\n", len(message))
            file, _ := os.OpenFile(outputFile, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
            file.Write(message)
            file.Close()
            continue
        }

        // テキストメッセージを処理します
        messageStr := string(message)
        fmt.Printf("Received text message: %s\n", strings.ReplaceAll(messageStr, "\n", ""))

        // JSON を解析してイベントタイプを取得します
        var msgMap map[string]interface{}
        if json.Unmarshal(message, &msgMap) == nil {
            if header, ok := msgMap["header"].(map[string]interface{}); ok {
                if event, ok := header["event"].(string); ok {
                    fmt.Printf("Event type: %s\n", event)

                    switch event {
                    case "task-started":
                        fmt.Println("=== Received task-started event ===")

                        if !textSent {
                            // continue-task コマンドを送信します。SSML を使用する場合、このコマンドは一度しか送信できません
                            continueTaskCmd := map[string]interface{}{
                                "header": map[string]interface{}{
                                    "action":    "continue-task",
                                    "task_id":   taskID,
                                    "streaming": "duplex",
                                },
                                "payload": map[string]interface{}{
                                    "input": map[string]interface{}{
                                        // 特殊文字をエスケープします
                                        "text": "<speak rate=\"2\">My speaking rate is faster than a normal person's.</speak>",
                                    },
                                },
                            }

                            continueTaskJSON, _ := json.Marshal(continueTaskCmd)
                            fmt.Printf("Sending continue-task command: %s\n", string(continueTaskJSON))

                            err = conn.WriteMessage(websocket.TextMessage, continueTaskJSON)
                            if err != nil {
                                fmt.Println("Failed to send continue-task:", err)
                                return
                            }

                            textSent = true

                            // finish-task の送信を遅らせます
                            time.Sleep(500 * time.Millisecond)

                            // finish-task コマンドを送信します
                            finishTaskCmd := map[string]interface{}{
                                "header": map[string]interface{}{
                                    "action":    "finish-task",
                                    "task_id":   taskID,
                                    "streaming": "duplex",
                                },
                                "payload": map[string]interface{}{
                                    "input": map[string]interface{}{},
                                },
                            }

                            finishTaskJSON, _ := json.Marshal(finishTaskCmd)
                            fmt.Printf("Sending finish-task command: %s\n", string(finishTaskJSON))

                            err = conn.WriteMessage(websocket.TextMessage, finishTaskJSON)
                            if err != nil {
                                fmt.Println("Failed to send finish-task:", err)
                                return
                            }
                        }

                    case "task-finished":
                        fmt.Println("=== Task finished ===")
                        return

                    case "task-failed":
                        fmt.Println("=== Task failed ===")
                        if header["error_message"] != nil {
                            fmt.Printf("Error message: %s\n", header["error_message"])
                        }
                        return

                    case "result-generated":
                        fmt.Println("Received result-generated event")
                    }
                }
            }
        }
    }
}

C#

using System.Net.WebSockets;
using System.Text;
using System.Text.Json;

// SSML の特徴に関する注意：
//     1. run-task コマンドで enable_ssml パラメーターを true に設定して SSML を有効にします。
//     2. continue-task コマンドを使用して SSML テキストを送信します。このコマンドは一度しか送信できません。
//     3. SSML は、cosyvoice-v3-flash、cosyvoice-v3-plus、および cosyvoice-v2 モデルのクローン音声、
//        および音声リストで SSML 対応とマークされたシステム音声 (例：cosyvoice-v3-flash の longanyang 音声) でのみサポートされます。
class Program {
    // シンガポールリージョンと北京リージョンの API キーは異なります。API キーの取得方法については、https://www.alibabacloud.com/help/model-studio/get-api-key をご参照ください
    // 環境変数を設定していない場合は、次の行を private static readonly string ApiKey = "sk-xxx" に置き換えてください
    private static readonly string ApiKey = Environment.GetEnvironmentVariable("DASHSCOPE_API_KEY") ?? throw new InvalidOperationException("DASHSCOPE_API_KEY environment variable is not set.");

    // 北京リージョンのモデルを使用する場合は、URL を wss://dashscope.aliyuncs.com/api-ws/v1/inference/ に置き換えてください
    private const string WebSocketUrl = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/";
    // 出力ファイルパス
    private const string OutputFilePath = "output.mp3";

    // WebSocket クライアント
    private static ClientWebSocket _webSocket = new ClientWebSocket();
    // キャンセルトークンソース
    private static CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
    // タスク ID
    private static string? _taskId;
    // タスクが開始されたかどうか
    private static TaskCompletionSource<bool> _taskStartedTcs = new TaskCompletionSource<bool>();

    static async Task Main(string[] args) {
        try {
            // 出力ファイルをクリアします
            ClearOutputFile(OutputFilePath);

            // WebSocket サービスに接続します
            await ConnectToWebSocketAsync(WebSocketUrl);

            // メッセージを受信するタスクを開始します
            Task receiveTask = ReceiveMessagesAsync();

            // run-task コマンドを送信します
            _taskId = GenerateTaskId();
            await SendRunTaskCommandAsync(_taskId);

            // task-started イベントを待ちます
            await _taskStartedTcs.Task;

            // continue-task コマンドを送信します。SSML 機能を使用する場合、このコマンドは一度しか送信できません。
            // 特殊文字はエスケープする必要があります。
            await SendContinueTaskCommandAsync("<speak rate=\"2\">My speaking rate is faster than a normal person's.</speak>");

            // finish-task コマンドを送信します
            await SendFinishTaskCommandAsync(_taskId);

            // 受信タスクが完了するのを待ちます
            await receiveTask;

            Console.WriteLine("Task completed, connection closed.");
        } catch (OperationCanceledException) {
            Console.WriteLine("The task was canceled.");
        } catch (Exception ex) {
            Console.WriteLine($"An error occurred: {ex.Message}");
        } finally {
            _cancellationTokenSource.Cancel();
            _webSocket.Dispose();
        }
    }

    private static void ClearOutputFile(string filePath) {
        if (File.Exists(filePath)) {
            File.WriteAllText(filePath, string.Empty);
            Console.WriteLine("The output file has been cleared.");
        } else {
            Console.WriteLine("The output file does not exist and does not need to be cleared.");
        }
    }

    private static async Task ConnectToWebSocketAsync(string url) {
        var uri = new Uri(url);
        if (_webSocket.State == WebSocketState.Connecting || _webSocket.State == WebSocketState.Open) {
            return;
        }

        // WebSocket 接続のヘッダーを設定します
        _webSocket.Options.SetRequestHeader("Authorization", $"bearer {ApiKey}");
        _webSocket.Options.SetRequestHeader("X-DashScope-DataInspection", "enable");

        try {
            await _webSocket.ConnectAsync(uri, _cancellationTokenSource.Token);
            Console.WriteLine("Successfully connected to the WebSocket service.");
        } catch (OperationCanceledException) {
            Console.WriteLine("WebSocket connection was canceled.");
        } catch (Exception ex) {
            Console.WriteLine($"WebSocket connection failed: {ex.Message}");
            throw;
        }
    }

    private static async Task SendRunTaskCommandAsync(string taskId) {
        var command = CreateCommand("run-task", taskId, "duplex", new {
            task_group = "audio",
            task = "tts",
            function = "SpeechSynthesizer",
            model = "cosyvoice-v3-flash",
            parameters = new
            {
                text_type = "PlainText",
                voice = "longanyang",
                format = "mp3",
                sample_rate = 22050,
                volume = 50,
                rate = 1,
                pitch = 1,
                // enable_ssml が true に設定されている場合、continue-task コマンドは一度しか送信できません。
                // そうしないと、「Text request limit violated, expected 1.」というエラーが表示されます。
                enable_ssml = true
            },
            input = new { }
        });

        await SendJsonMessageAsync(command);
        Console.WriteLine("Sent run-task command.");
    }

    private static async Task SendContinueTaskCommandAsync(string text) {
        if (_taskId == null) {
            throw new InvalidOperationException("Task ID is not initialized.");
        }

        var command = CreateCommand("continue-task", _taskId, "duplex", new {
            input = new {
                text
            }
        });

        await SendJsonMessageAsync(command);
        Console.WriteLine("Sent continue-task command.");
    }

    private static async Task SendFinishTaskCommandAsync(string taskId) {
        var command = CreateCommand("finish-task", taskId, "duplex", new {
            input = new { }
        });

        await SendJsonMessageAsync(command);
        Console.WriteLine("Sent finish-task command.");
    }

    private static async Task SendJsonMessageAsync(string message) {
        var buffer = Encoding.UTF8.GetBytes(message);
        try {
            await _webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, _cancellationTokenSource.Token);
        } catch (OperationCanceledException) {
            Console.WriteLine("Message sending was canceled.");
        }
    }

    private static async Task ReceiveMessagesAsync() {
        while (_webSocket.State == WebSocketState.Open) {
            var response = await ReceiveMessageAsync();
            if (response != null) {
                var eventStr = response.RootElement.GetProperty("header").GetProperty("event").GetString();
                switch (eventStr) {
                    case "task-started":
                        Console.WriteLine("Task started.");
                        _taskStartedTcs.TrySetResult(true);
                        break;
                    case "task-finished":
                        Console.WriteLine("Task finished.");
                        _cancellationTokenSource.Cancel();
                        break;
                    case "task-failed":
                        Console.WriteLine("Task failed: " + response.RootElement.GetProperty("header").GetProperty("error_message").GetString());
                        _cancellationTokenSource.Cancel();
                        break;
                    default:
                        // result-generated はここで処理できます
                        break;
                }
            }
        }
    }

    private static async Task<JsonDocument?> ReceiveMessageAsync() {
        var buffer = new byte[1024 * 4];
        var segment = new ArraySegment<byte>(buffer);

        try {
            WebSocketReceiveResult result = await _webSocket.ReceiveAsync(segment, _cancellationTokenSource.Token);

            if (result.MessageType == WebSocketMessageType.Close) {
                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", _cancellationTokenSource.Token);
                return null;
            }

            if (result.MessageType == WebSocketMessageType.Binary) {
                // バイナリデータを処理します
                Console.WriteLine("Receiving binary data...");

                // バイナリデータをファイルに保存します
                using (var fileStream = new FileStream(OutputFilePath, FileMode.Append)) {
                    fileStream.Write(buffer, 0, result.Count);
                }

                return null;
            }

            string message = Encoding.UTF8.GetString(buffer, 0, result.Count);
            return JsonDocument.Parse(message);
        } catch (OperationCanceledException) {
            Console.WriteLine("Message reception was canceled.");
            return null;
        }
    }

    private static string GenerateTaskId() {
        return Guid.NewGuid().ToString("N").Substring(0, 32);
    }

    private static string CreateCommand(string action, string taskId, string streaming, object payload) {
        var command = new {
            header = new {
                action,
                task_id = taskId,
                streaming
            },
            payload
        };

        return JsonSerializer.Serialize(command);
    }
}

PHP

サンプルコードには次のディレクトリ構造があります：

my-php-project/

├── composer.json

├── vendor/

└── index.php

以下は composer.json の内容です。実際のニーズに基づいて依存関係のバージョン番号を決定してください：

{
    "require": {
        "react/event-loop": "^1.3",
        "react/socket": "^1.11",
        "react/stream": "^1.2",
        "react/http": "^1.1",
        "ratchet/pawl": "^0.4"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

以下は index.php の内容です：

<!-- SSML の特徴に関する注意： -->
<!--     1. run-task コマンドを送信する際に、enable_ssml パラメーターを true に設定して SSML サポートを有効にします。 -->
<!--     2. continue-task コマンドを使用して SSML を含むテキストを送信します。このコマンドは一度しか送信できません。 -->
<!--     3. SSML は、cosyvoice-v3-flash、cosyvoice-v3-plus、および cosyvoice-v2 モデルのクローン音声、および音声リストで SSML 対応とマークされたシステム音声 (例：cosyvoice-v3-flash の longanyang 音声) でのみサポートされます。 -->

<?php

require __DIR__ . '/vendor/autoload.php';

use Ratchet\Client\Connector;
use React\EventLoop\Loop;
use React\Socket\Connector as SocketConnector;

// シンガポールリージョンと北京リージョンの API キーは異なります。API キーの取得方法については、https://www.alibabacloud.com/help/model-studio/get-api-key をご参照ください
// 環境変数を設定していない場合は、次の行を $api_key = "sk-xxx" に置き換えてください
$api_key = getenv("DASHSCOPE_API_KEY");
// 次の URL はシンガポールリージョン用です。北京リージョンのモデルを使用する場合は、URL を wss://dashscope.aliyuncs.com/api-ws/v1/inference/ に置き換えてください
$websocket_url = 'wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/'; // WebSocket サーバーアドレス
$output_file = 'output.mp3'; // 出力ファイルパス

$loop = Loop::get();

if (file_exists($output_file)) {
    // ファイルの内容をクリアします
    file_put_contents($output_file, '');
}

// カスタムコネクタを作成します
$socketConnector = new SocketConnector($loop, [
    'tcp' => [
        'bindto' => '0.0.0.0:0',
    ],
    'tls' => [
        'verify_peer' => false,
        'verify_peer_name' => false,
    ],
]);

$connector = new Connector($loop, $socketConnector);

$headers = [
    'Authorization' => 'bearer ' . $api_key,
    'X-DashScope-DataInspection' => 'enable'
];

$connector($websocket_url, [], $headers)->then(function ($conn) use ($loop, $output_file) {
    echo "Connected to WebSocket server\n";

    // タスク ID を生成します
    $taskId = generateTaskId();

    // run-task コマンドを送信します
    sendRunTaskMessage($conn, $taskId);

    // continue-task コマンドを送信する関数を定義します
    $sendContinueTask = function() use ($conn, $loop, $taskId) {
        // continue-task コマンドを送信します。SSML 機能を使用する場合、このコマンドは一度しか送信できません。
        $continueTaskMessage = json_encode([
            "header" => [
                "action" => "continue-task",
                "task_id" => $taskId,
                "streaming" => "duplex"
            ],
            "payload" => [
                "input" => [
                    // 特殊文字はエスケープする必要があります
                    "text" => "<speak rate=\"2\">My speaking rate is faster than a normal person's.</speak>"
                ]
            ]
        ]);
        $conn->send($continueTaskMessage);

        // finish-task コマンドを送信します
        sendFinishTaskMessage($conn, $taskId);
    };

    // task-started イベントが受信されたかどうかを確認するフラグ
    $taskStarted = false;

    // メッセージをリッスンします
    $conn->on('message', function($msg) use ($conn, $sendContinueTask, $loop, &$taskStarted, $taskId, $output_file) {
        if ($msg->isBinary()) {
            // バイナリデータをローカルファイルに書き込みます
            file_put_contents($output_file, $msg->getPayload(), FILE_APPEND);
        } else {
            // 非バイナリメッセージを処理します
            $response = json_decode($msg, true);

            if (isset($response['header']['event'])) {
                handleEvent($conn, $response, $sendContinueTask, $loop, $taskId, $taskStarted);
            } else {
                echo "Unknown message format\n";
            }
        }
    });

    // 接続クローズをリッスンします
    $conn->on('close', function($code = null, $reason = null) {
        echo "Connection closed\n";
        if ($code !== null) {
            echo "Close code: " . $code . "\n";
        }
        if ($reason !== null) {
            echo "Close reason: " . $reason . "\n";
        }
    });
}, function ($e) {
    echo "Could not connect: {$e->getMessage()}\n";
});

$loop->run();

/**
 * タスク ID を生成します
 * @return string
 */
function generateTaskId(): string {
    return bin2hex(random_bytes(16));
}

/**
 * run-task コマンドを送信します
 * @param $conn
 * @param $taskId
 */
function sendRunTaskMessage($conn, $taskId) {
    $runTaskMessage = json_encode([
        "header" => [
            "action" => "run-task",
            "task_id" => $taskId,
            "streaming" => "duplex"
        ],
        "payload" => [
            "task_group" => "audio",
            "task" => "tts",
            "function" => "SpeechSynthesizer",
            "model" => "cosyvoice-v3-flash",
            "parameters" => [
                "text_type" => "PlainText",
                "voice" => "longanyang",
                "format" => "mp3",
                "sample_rate" => 22050,
                "volume" => 50,
                "rate" => 1,
                "pitch" => 1,
                // enable_ssml が true に設定されている場合、continue-task コマンドは一度しか送信できません。
                // そうしないと、「Text request limit violated, expected 1.」というエラーが表示されます。
                "enable_ssml" => true
            ],
            "input" => (object) []
        ]
    ]);
    echo "Preparing to send run-task command: " . $runTaskMessage . "\n";
    $conn->send($runTaskMessage);
    echo "run-task command sent\n";
}

/**
 * 音声ファイルを読み取ります
 * @param string $filePath
 * @return bool|string
 */
function readAudioFile(string $filePath) {
    $voiceData = file_get_contents($filePath);
    if ($voiceData === false) {
        echo "Failed to read audio file\n";
    }
    return $voiceData;
}

/**
 * 音声データを分割します
 * @param string $data
 * @param int $chunkSize
 * @return array
 */
function splitAudioData(string $data, int $chunkSize): array {
    return str_split($data, $chunkSize);
}

/**
 * finish-task コマンドを送信します
 * @param $conn
 * @param $taskId
 */
function sendFinishTaskMessage($conn, $taskId) {
    $finishTaskMessage = json_encode([
        "header" => [
            "action" => "finish-task",
            "task_id" => $taskId,
            "streaming" => "duplex"
        ],
        "payload" => [
            "input" => (object) []
        ]
    ]);
    echo "Preparing to send finish-task command: " . $finishTaskMessage . "\n";
    $conn->send($finishTaskMessage);
    echo "finish-task command sent\n";
}

/**
 * イベントを処理します
 * @param $conn
 * @param $response
 * @param $sendContinueTask
 * @param $loop
 * @param $taskId
 * @param $taskStarted
 */
function handleEvent($conn, $response, $sendContinueTask, $loop, $taskId, &$taskStarted) {
    switch ($response['header']['event']) {
        case 'task-started':
            echo "Task started, sending continue-task command...\n";
            $taskStarted = true;
            // continue-task コマンドを送信します
            $sendContinueTask();
            break;
        case 'result-generated':
            // result-generated イベントを無視します
            break;
        case 'task-finished':
            echo "Task finished\n";
            $conn->close();
            break;
        case 'task-failed':
            echo "Task failed\n";
            echo "Error code: " . $response['header']['error_code'] . "\n";
            echo "Error message: " . $response['header']['error_message'] . "\n";
            $conn->close();
            break;
        case 'error':
            echo "Error: " . $response['payload']['message'] . "\n";
            break;
        default:
            echo "Unknown event: " . $response['header']['event'] . "\n";
            break;
    }

    // タスクが終了した場合、接続を閉じます
    if ($response['header']['event'] == 'task-finished') {
        // すべてのデータが転送されるように 1 秒待機します
        $loop->addTimer(1, function() use ($conn) {
            $conn->close();
            echo "Client closes connection\n";
        });
    }

    // task-started イベントが受信されない場合、接続を閉じます
    if (!$taskStarted && in_array($response['header']['event'], ['task-failed', 'error'])) {
        $conn->close();
    }
}

Node.js

必要な依存関係をインストールする必要があります：

npm install ws
npm install uuid

サンプルコードは次のとおりです：

// SSML の特徴に関する注意：
//     1. run-task コマンドで enable_ssml パラメーターを true に設定して SSML を有効にします。
//     2. continue-task コマンドを使用して SSML テキストを送信します。このコマンドは一度しか送信できません。
//     3. SSML は、cosyvoice-v3-flash、cosyvoice-v3-plus、および cosyvoice-v2 モデルのクローン音声、
//        および音声リストで SSML 対応とマークされたシステム音声 (例：cosyvoice-v3-flash の longanyang 音声) でのみサポートされます。

import fs from 'fs';
import WebSocket from 'ws';
import { v4 as uuid } from 'uuid'; // UUID の生成に使用します

// シンガポールリージョンと北京リージョンの API キーは異なります。API キーの取得方法については、https://www.alibabacloud.com/help/model-studio/get-api-key をご参照ください
// 環境変数を設定していない場合は、次の行を const apiKey = "sk-xxx" に置き換えてください
const apiKey = process.env.DASHSCOPE_API_KEY;
// 次の URL はシンガポールリージョン用です。北京リージョンのモデルを使用する場合は、URL を wss://dashscope.aliyuncs.com/api-ws/v1/inference/ に置き換えてください
const url = 'wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/';
// 出力ファイルパス
const outputFilePath = 'output.mp3';

// 出力ファイルをクリアします
fs.writeFileSync(outputFilePath, '');

// WebSocket クライアントを作成します
const ws = new WebSocket(url, {
  headers: {
    Authorization: `bearer ${apiKey}`,
    'X-DashScope-DataInspection': 'enable'
  }
});

let taskStarted = false;
let taskId = uuid();

ws.on('open', () => {
  console.log('Connected to WebSocket server');

  // run-task コマンドを送信します
  const runTaskMessage = JSON.stringify({
    header: {
      action: 'run-task',
      task_id: taskId,
      streaming: 'duplex'
    },
    payload: {
      task_group: 'audio',
      task: 'tts',
      function: 'SpeechSynthesizer',
      model: 'cosyvoice-v3-flash',
      parameters: {
        text_type: 'PlainText',
        voice: 'longanyang', // 音声
        format: 'mp3', // 音声フォーマット
        sample_rate: 22050, // サンプルレート
        volume: 50, // 音量
        rate: 1, // 話速
        pitch: 1, // ピッチ
        enable_ssml: true // SSML 機能を有効にするかどうか。enable_ssml が true に設定されている場合、continue-task コマンドは一度しか送信できません。そうしないと、「Text request limit violated, expected 1.」というエラーが報告されます。
      },
      input: {}
    }
  });
  ws.send(runTaskMessage);
  console.log('Sent run-task message');
});

const fileStream = fs.createWriteStream(outputFilePath, { flags: 'a' });
ws.on('message', (data, isBinary) => {
  if (isBinary) {
    // バイナリデータをファイルに書き込みます
    fileStream.write(data);
  } else {
    const message = JSON.parse(data);

    switch (message.header.event) {
      case 'task-started':
        taskStarted = true;
        console.log('Task has started');
        // continue-task コマンドを送信します
        sendContinueTasks(ws);
        break;
      case 'task-finished':
        console.log('Task has finished');
        ws.close();
        fileStream.end(() => {
          console.log('File stream has been closed');
        });
        break;
      case 'task-failed':
        console.error('Task failed: ', message.header.error_message);
        ws.close();
        fileStream.end(() => {
          console.log('File stream has been closed');
        });
        break;
      default:
        // ここで result-generated を処理できます
        break;
    }
  }
});

function sendContinueTasks(ws) {
  
  if (taskStarted) {
    // continue-task コマンドを送信します。SSML 機能を使用する場合、このコマンドは一度しか送信できません。
    const continueTaskMessage = JSON.stringify({
      header: {
        action: 'continue-task',
        task_id: taskId,
        streaming: 'duplex'
      },
      payload: {
        input: {
          // 特殊文字はエスケープする必要があります
          text: '<speak rate="2">My speaking rate is faster than a normal person's.</speak>'
        }
      }
    });
    ws.send(continueTaskMessage);
    
    // finish-task コマンドを送信します
    const finishTaskMessage = JSON.stringify({
      header: {
        action: 'finish-task',
        task_id: taskId,
        streaming: 'duplex'
      },
      payload: {
        input: {}
      }
    });
    ws.send(finishTaskMessage);
  }
}

ws.on('close', () => {
  console.log('Disconnected from the WebSocket server');
});

Java

Java プログラミング言語を使用する場合、開発には Java DashScope SDK を使用することを推奨します。詳細については、「Java SDK」をご参照ください。

以下は Java WebSocket のサンプルです。サンプルを実行する前に、次の依存関係をインポートしていることを確認してください：

• Java-WebSocket

• jackson-databind

Maven または Gradle を使用して依存関係パッケージを管理することを推奨します。構成は次のとおりです：

<dependencies>
    <!-- WebSocket Client -->
    <dependency>
        <groupId>org.java-websocket</groupId>
        <artifactId>Java-WebSocket</artifactId>
        <version>1.5.3</version>
    </dependency>

    <!-- JSON Processing -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.13.0</version>
    </dependency>
</dependencies>

// 他のコードを省略
dependencies {
  // WebSocket Client
  implementation 'org.java-websocket:Java-WebSocket:1.5.3'
  // JSON Processing
  implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.0'
}
// 他のコードを省略

Java コードは次のとおりです：

import com.fasterxml.jackson.databind.ObjectMapper;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;

import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;
import java.nio.ByteBuffer;
import java.util.*;

/**
 * SSML の特徴に関する注意：
 *     1. run-task コマンドを送信する際に、enable_ssml パラメーターを true に設定して SSML サポートを有効にします。
 *     2. continue-task コマンドを使用して SSML を含むテキストを送信します。このコマンドは一度しか送信できません。
 *     3. SSML は、cosyvoice-v3-flash、cosyvoice-v3-plus、および cosyvoice-v2 モデルのクローン音声、および音声リストで SSML 対応とマークされたシステム音声 (例：cosyvoice-v3-flash の longanyang 音声) でのみサポートされます。
 */
public class TTSWebSocketClient extends WebSocketClient {
    private final String taskId = UUID.randomUUID().toString();
    private final String outputFile = "output_" + System.currentTimeMillis() + ".mp3";
    private boolean taskFinished = false;

    public TTSWebSocketClient(URI serverUri, Map<String, String> headers) {
        super(serverUri, headers);
    }

    @Override
    public void onOpen(ServerHandshake serverHandshake) {
        System.out.println("Connection successful");

        // run-task コマンドを送信します
        // enable_ssml が true に設定されている場合、continue-task コマンドは一度しか送信できません。
        // そうしないと、「Text request limit violated, expected 1.」というエラーが表示されます。
        String runTaskCommand = "{ \"header\": { \"action\": \"run-task\", \"task_id\": \"" + taskId + "\", \"streaming\": \"duplex\" }, \"payload\": { \"task_group\": \"audio\", \"task\": \"tts\", \"function\": \"SpeechSynthesizer\", \"model\": \"cosyvoice-v3-flash\", \"parameters\": { \"text_type\": \"PlainText\", \"voice\": \"longanyang\", \"format\": \"mp3\", \"sample_rate\": 22050, \"volume\": 50, \"rate\": 1, \"pitch\": 1, \"enable_ssml\": true }, \"input\": {} }}";
        send(runTaskCommand);
    }

    @Override
    public void onMessage(String message) {
        System.out.println("Received message from server: " + message);
        try {
            // JSON メッセージを解析します
            Map<String, Object> messageMap = new ObjectMapper().readValue(message, Map.class);

            if (messageMap.containsKey("header")) {
                Map<String, Object> header = (Map<String, Object>) messageMap.get("header");

                if (header.containsKey("event")) {
                    String event = (String) header.get("event");

                    if ("task-started".equals(event)) {
                        System.out.println("Received task-started event from server");

                        // continue-task コマンドを送信します。SSML 機能を使用する場合、このコマンドは一度しか送信できません。
                        // 特殊文字はエスケープする必要があります。
                        sendContinueTask("<speak rate=\\\"2\\\">My speaking rate is faster than a normal person's.</speak>");

                        // finish-task コマンドを送信します
                        sendFinishTask();
                    } else if ("task-finished".equals(event)) {
                        System.out.println("Received task-finished event from server");
                        taskFinished = true;
                        closeConnection();
                    } else if ("task-failed".equals(event)) {
                        System.out.println("Task failed: " + message);
                        closeConnection();
                    }
                }
            }
        } catch (Exception e) {
            System.err.println("An exception occurred: " + e.getMessage());
        }
    }

    @Override
    public void onMessage(ByteBuffer message) {
        System.out.println("Size of received binary audio data: " + message.remaining());

        try (FileOutputStream fos = new FileOutputStream(outputFile, true)) {
            byte[] buffer = new byte[message.remaining()];
            message.get(buffer);
            fos.write(buffer);
            System.out.println("Audio data has been written to the local file " + outputFile);
        } catch (IOException e) {
            System.err.println("Failed to write audio data to local file: " + e.getMessage());
        }
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        System.out.println("Connection closed: " + reason + " (" + code + ")");
    }

    @Override
    public void onError(Exception ex) {
        System.err.println("Error: " + ex.getMessage());
        ex.printStackTrace();
    }

    private void sendContinueTask(String text) {
        String command = "{ \"header\": { \"action\": \"continue-task\", \"task_id\": \"" + taskId + "\", \"streaming\": \"duplex\" }, \"payload\": { \"input\": { \"text\": \"" + text + "\" } }}";
        send(command);
    }

    private void sendFinishTask() {
        String command = "{ \"header\": { \"action\": \"finish-task\", \"task_id\": \"" + taskId + "\", \"streaming\": \"duplex\" }, \"payload\": { \"input\": {} }}";
        send(command);
    }

    private void closeConnection() {
        if (!isClosed()) {
            close();
        }
    }

    public static void main(String[] args) {
        try {
            // シンガポールリージョンと北京リージョンの API キーは異なります。API キーの取得方法については、https://www.alibabacloud.com/help/model-studio/get-api-key をご参照ください
            // 環境変数を設定していない場合は、次の行を String apiKey = "sk-xxx" に置き換えてください
            String apiKey = System.getenv("DASHSCOPE_API_KEY");
            if (apiKey == null || apiKey.isEmpty()) {
                System.err.println("Please set the DASHSCOPE_API_KEY environment variable");
                return;
            }

            Map<String, String> headers = new HashMap<>();
            headers.put("Authorization", "bearer " + apiKey);
            // 北京リージョンのモデルを使用する場合は、URL を wss://dashscope.aliyuncs.com/api-ws/v1/inference/ に置き換えてください
            TTSWebSocketClient client = new TTSWebSocketClient(new URI("wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/"), headers);

            client.connect();

            while (!client.isClosed() && !client.taskFinished) {
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            System.err.println("Failed to connect to WebSocket service: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Python

Python を使用する場合、開発には Python DashScope SDK を使用することを推奨します。「Python SDK」をご参照ください。

以下は Python WebSocket のサンプルです。サンプルを実行する前に、次の方法で依存関係をインポートしてください：

pip uninstall websocket-client
pip uninstall websocket
pip install websocket-client

# SSML の特徴に関する注意：
#     1. run-task コマンドを送信する際に、enable_ssml パラメーターを true に設定して SSML サポートを有効にします。
#     2. continue-task コマンドを使用して SSML を含むテキストを送信します。このコマンドは一度しか送信できません。
#     3. SSML は、cosyvoice-v3-flash、cosyvoice-v3-plus、および cosyvoice-v2 モデルのクローン音声、および音声リストで SSML 対応とマークされたシステム音声 (例：cosyvoice-v3-flash の longanyang 音声) でのみサポートされます。

import websocket
import json
import uuid
import os
import time


class TTSClient:
    def __init__(self, api_key, uri):
        """
    TTSClient インスタンスを初期化します。

    パラメーター：
        api_key (str): 認証用の API キー。
        uri (str): WebSocket サービスアドレス。
    """
        self.api_key = api_key  # API キーに置き換えてください。
        self.uri = uri  # WebSocket アドレスに置き換えてください。
        self.task_id = str(uuid.uuid4())  # 一意のタスク ID を生成します。
        self.output_file = f"output_{int(time.time())}.mp3"  # 出力音声ファイルパス。
        self.ws = None  # WebSocketApp インスタンス。
        self.task_started = False  # task-started を受信したかどうか。
        self.task_finished = False  # task-finished/task-failed を受信したかどうか。

    def on_open(self, ws):
        """
    WebSocket 接続が確立されたときのコールバック関数。
    run-task コマンドを送信して音声合成タスクを開始します。
    """
        print("WebSocket connection established")

        # run-task コマンドを構築します。
        run_task_cmd = {
            "header": {
                "action": "run-task",
                "task_id": self.task_id,
                "streaming": "duplex"
            },
            "payload": {
                "task_group": "audio",
                "task": "tts",
                "function": "SpeechSynthesizer",
                "model": "cosyvoice-v3-flash",
                "parameters": {
                    "text_type": "PlainText",
                    "voice": "longanyang",
                    "format": "mp3",
                    "sample_rate": 22050,
                    "volume": 50,
                    "rate": 1,
                    "pitch": 1,
                    # enable_ssml が true に設定されている場合、continue-task コマンドは一度しか送信できません。
                    # そうしないと、「Text request limit violated, expected 1.」というエラーが表示されます。
                    "enable_ssml": True
                },
                "input": {}
            }
        }

        # run-task コマンドを送信します。
        ws.send(json.dumps(run_task_cmd))
        print("run-task command sent")

    def on_message(self, ws, message):
        """
    メッセージを受信したときのコールバック関数。
    テキストメッセージとバイナリメッセージを別々に処理します。
    """
        if isinstance(message, str):
            # JSON テキストメッセージを処理します。
            try:
                msg_json = json.loads(message)
                print(f"Received JSON message: {msg_json}")

                if "header" in msg_json:
                    header = msg_json["header"]

                    if "event" in header:
                        event = header["event"]

                        if event == "task-started":
                            print("Task started")
                            self.task_started = True

                            # continue-task コマンドを送信します。SSML 機能を使用する場合、このコマンドは一度しか送信できません。
                            # 特殊文字はエスケープする必要があります。
                            self.send_continue_task("<speak rate=\"2\">My speaking rate is faster than a normal person's.</speak>")

                            # continue-task が送信された後、finish-task を送信します。
                            self.send_finish_task()

                        elif event == "task-finished":
                            print("Task finished")
                            self.task_finished = True
                            self.close(ws)

                        elif event == "task-failed":
                            error_msg = msg_json.get("error_message", "Unknown error")
                            print(f"Task failed: {error_msg}")
                            self.task_finished = True
                            self.close(ws)

            except json.JSONDecodeError as e:
                print(f"JSON parsing failed: {e}")
        else:
            # バイナリメッセージ (音声データ) を処理します。
            print(f"Received binary message, size: {len(message)} bytes")
            with open(self.output_file, "ab") as f:
                f.write(message)
            print(f"Audio data has been written to the local file {self.output_file}")

    def on_error(self, ws, error):
        """エラー時のコールバック。"""
        print(f"WebSocket error: {error}")

    def on_close(self, ws, close_status_code, close_msg):
        """クローズ時のコールバック。"""
        print(f"WebSocket closed: {close_msg} ({close_status_code})")

    def send_continue_task(self, text):
        """合成するテキストを含む continue-task コマンドを送信します。"""
        cmd = {
            "header": {
                "action": "continue-task",
                "task_id": self.task_id,
                "streaming": "duplex"
            },
            "payload": {
                "input": {
                    "text": text
                }
            }
        }

        self.ws.send(json.dumps(cmd))
        print(f"Sent continue-task command, text content: {text}")

    def send_finish_task(self):
        """音声合成タスクを終了するための finish-task コマンドを送信します。"""
        cmd = {
            "header": {
                "action": "finish-task",
                "task_id": self.task_id,
                "streaming": "duplex"
            },
            "payload": {
                "input": {}
            }
        }

        self.ws.send(json.dumps(cmd))
        print("Sent finish-task command")

    def close(self, ws):
        """接続を能動的に閉じます。"""
        if ws and ws.sock and ws.sock.connected:
            ws.close()
            print("Connection actively closed")

    def run(self):
        """WebSocket クライアントを開始します。"""
        # リクエストヘッダー (認証) を設定します。
        header = {
            "Authorization": f"bearer {self.api_key}",
            "X-DashScope-DataInspection": "enable"
        }

        # WebSocketApp インスタンスを作成します。
        self.ws = websocket.WebSocketApp(
            self.uri,
            header=header,
            on_open=self.on_open,
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close
        )

        print("Listening for WebSocket messages...")
        self.ws.run_forever()  # 持続的接続リスナーを開始します。


# 使用例
if __name__ == "__main__":
    # シンガポールリージョンと北京リージョンの API キーは異なります。API キーの取得方法については、https://www.alibabacloud.com/help/model-studio/get-api-key をご参照ください
    # 環境変数を設定していない場合は、次の行を API_KEY = "sk-xxx" に置き換えてください
    API_KEY = os.environ.get("DASHSCOPE_API_KEY")
    # 次の URL はシンガポールリージョン用です。北京リージョンのモデルを使用する場合は、URL を wss://dashscope.aliyuncs.com/api-ws/v1/inference/ に置き換えてください
    SERVER_URI = "wss://dashscope-intl.aliyuncs.com/api-ws/v1/inference/"

    client = TTSClient(API_KEY, SERVER_URI)
    client.run()