### Audio Translation with Go SDK Source: https://www.volcengine.com/docs/4640/78985 This example demonstrates how to initialize the Volcengine client, submit an audio file for translation, and poll the status until completion to retrieve the translated subtitles. ```go package main import ( "encoding/json" "fmt" "net/http" "net/url" "time" "github.com/volcengine/volc-sdk-golang/base" ) const ( kAccessKey = "密钥管理中的 AccessKey ID" // https://console.volcengine.com/iam/keymanage/ kSecretKey = "密钥管理中的 AccessKey Secret" kServiceVersion = "2020-06-01" ) var ( ServiceInfo = &base.ServiceInfo{ Timeout: 5 * time.Second, Host: "translate.volcengineapi.com", Header: http.Header{ "Accept": []string{"application/json"}, }, Credentials: base.Credentials{Region: base.RegionCnNorth1, Service: "translate"}, } ApiInfoList = map[string]*base.ApiInfo{ "SubmitAudio": { Method: http.MethodPost, Path: "/", Query: url.Values{ "Action": []string{"SubmitAudio"}, "Version": []string{kServiceVersion}, }, }, "QueryAudio": { Method: http.MethodPost, Path: "/", Query: url.Values{ "Action": []string{"QueryAudio"}, "Version": []string{kServiceVersion}, }, }, } ) func newClient() *base.Client { client := base.NewClient(ServiceInfo, ApiInfoList) client.SetAccessKey(kAccessKey) client.SetSecretKey(kSecretKey) return client } type SubmitReq struct { SourceLanguage string `json:"SourceLanguage"` TargetLanguage string `json:"TargetLanguage"` Uri string `json:"Uri"` } type SubmitResp struct { TaskId string `json:"TaskId"` ResponseMetadata struct { RequestId string `json:"RequestId"` Action string `json:"Action"` Version string `json:"Version"` Service string `json:"Service"` Region string `json:"Region"` Error interface{} `json:"Error"` } `json:"ResponseMetadata"` } type QueryReq struct { TaskId string `json:"TaskId"` } type QueryResp struct { Subtitles []struct { StartTime int `json:"StartTime"` EndTime int `json:"EndTime"` Text string `json:"Text"` Translation string `json:"Translation"` } `json:"Subtitles"` Status string `json:"Status"` ResponseMetadata struct { RequestId string `json:"RequestId"` Action string `json:"Action"` Version string `json:"Version"` Service string `json:"Service"` Region string `json:"Region"` Error interface{} `json:"Error"` } `json:"ResponseMetadata"` } func SubmitAudio(cli *base.Client, uri, sourceLanguage, targetLanguage string) (*SubmitResp, error) { req := &SubmitReq{ SourceLanguage: sourceLanguage, TargetLanguage: targetLanguage, Uri: uri, } reqData, err := json.Marshal(req) if err != nil { return nil, err } respData, code, err := cli.Json("SubmitAudio", nil, string(reqData)) if err != nil { return nil, err } if code != 200 { return nil, fmt.Errorf("code:%d,err:%s", code, string(respData)) } resp := &SubmitResp{} err = json.Unmarshal(respData, resp) if err != nil { return nil, err } return resp, nil } func QueryAudio(cli *base.Client, taskId string) (*QueryResp, error) { req := &QueryReq{ TaskId: taskId, } reqData, err := json.Marshal(req) if err != nil { return nil, err } respData, code, err := cli.Json("QueryAudio", nil, string(reqData)) if err != nil { return nil, err } if code != 200 { return nil, fmt.Errorf("code:%d,err:%s", code, string(respData)) } resp := &QueryResp{} err = json.Unmarshal(respData, resp) if err != nil { return nil, err } return resp, nil } func main() { cli := newClient() submitResp, err := SubmitAudio(cli, "http://xx/xx.mp4", "en", "zh") if err != nil { panic(err) } status := "created" for status == "created" { time.Sleep(time.Minute) queryResp, err := QueryAudio(cli, submitResp.TaskId) if err != nil { panic(err) } status = queryResp.Status if status == "success" { for _, subtitle := range queryResp.Subtitles { fmt.Printf("%d - %d: %s -> %s", subtitle.StartTime, subtitle.EndTime, subtitle.Text, subtitle.Translation) } } } } ``` -------------------------------- ### Go: WebSocket speech translation client with signing and streaming Source: https://www.volcengine.com/docs/4640/127504 Go example showing how to sign a WebSocket URL using the Volcengine SDK, connect, send audio chunks, and receive translation results. It uses a WaitGroup to manage concurrent read/write goroutines and sends a JSON configuration message with source language 'en' and target 'zh'. ```go func getWsSignUrl(host string, accessKey string, secretKey string) (string, error) { client := newClient(host, accessKey, secretKey) signUrl, err := client.GetSignUrl(kSpeechTranslateAction, nil) if err != nil { return "", err } clientUrl := url.URL{ Scheme: "wss", Path: client.ApiInfoList[kSpeechTranslateAction].Path, Host: client.ServiceInfo.Host, RawQuery: signUrl, } return clientUrl.String(), nil } func main() { var ( group = &sync.WaitGroup{} buffer = make([]byte, 200*32) dialer = &websocket.Dialer{} header = http.Header{} ) r, err := fromLocal("audio.wav") if err != nil { panic(err) return } signUrl, err := getWsSignUrl(kHost, accessKey, secretKey) if err != nil { panic(err) return } group.Add(2) header.Set("content-type", "application/json") conn, resp, err := dialer.Dial(signUrl, header) if err != nil { println(resp.Status) panic(err) } if err = conn.WriteMessage(websocket.BinaryMessage, []byte(`{"Configuration":{"SourceLanguage":"en","TargetLanguages":["zh"]}}`)); err != nil { panic(err) } go func() { defer group.Done() for { _, data, err := conn.ReadMessage() if err != nil { println(err.Error()) return } println(string(data)) } }() go func() { defer group.Done() for { _, err = r.Read(buffer) if err != nil { println(err.Error()) if err == io.EOF { if err = conn.WriteMessage(websocket.BinaryMessage, []byte(`{"End":true}`)); err != nil { panic(err) } } return } err = conn.WriteMessage(websocket.BinaryMessage, newAudioData(buffer)) if err != nil { panic(err) return } time.Sleep(200 * time.Millisecond) } }() group.Wait() } ``` -------------------------------- ### Java WebSocket Speech Translation Client Source: https://www.volcengine.com/docs/4640/127504 This Java example shows how to use the Volcengine TranslateService to create a signed WebSocket URL and stream audio for translation. It sends a configuration message with source and target languages, then sends audio data in chunks, and finally sends an end message. The code assumes the presence of TranslateConfig and Client classes. ```java //src/main/java/Main.java import translate.TranslateConfig; import translate.TranslateService; import websocket.Client; import java.io.File; import java.io.FileInputStream; import java.net.URI; import java.util.Base64; public class Main { public static void main(String[] args) throws Exception { File input = new File("audio.wav"); TranslateService translateService = new TranslateService(TranslateConfig.serviceInfo, TranslateConfig.apiInfoList); translateService.setAccessKey(TranslateConfig.accessKey); translateService.setSecretKey(TranslateConfig.secretKey); String signUrl = translateService.getSignUrl(TranslateConfig.api, null); URI url = new URI("wss://" + TranslateConfig.host + TranslateConfig.path + "?" + signUrl); System.out.println(url); // open websocket Client client = new Client(url); client.connectBlocking(); client.send("{\n" + " \"Configuration\": {\n" + " \"SourceLanguage\": \"zh\",\n" + " \"TargetLanguages\": [\n" + " \"en\"\n" + " ],\n" + " \"HotWordList\": [\n" + " {\n" + " \"Word\": \"hello\",\n" + " \"Scale\": 1\n" + " }\n" + " ]\n" + " }\n" + "}"); byte[] buffer = new byte[200 * 32]; int bytesLeft = 100 * 1024 * 1024; try (FileInputStream fis = new FileInputStream(input)) { while (bytesLeft > 0) { int read = fis.read(buffer, 0, Math.min(bytesLeft, buffer.length)); if (read == -1) { break; } client.send(bytesToMessage(buffer)); Thread.sleep(200); bytesLeft -= read; } } finally { client.send("{\n" + " \"End\": true\n" + "}"); } } static String bytesToMessage(byte[] data) { String base64Data = Base64.getEncoder().encodeToString(data); return "{\n" + " \"AudioData\": \"" + base64Data + "\"\n" + "}"; } } java ``` -------------------------------- ### 使用 Go 调用文本语种检测API Source: https://www.volcengine.com/docs/4640/65066 使用 volc-sdk-golang 进行语种检测的示例代码。通过配置 ServiceInfo 和 ApiInfoList 来初始化客户端并发送请求。 ```golang package main import ( "fmt" "net/http" "net/url" "time" "github.com/volcengine/volc-sdk-golang/base" ) const ( kAccessKey = "密钥管理中的 AccessKey ID" // https://console.volcengine.com/iam/keymanage/ kSecretKey = "密钥管理中的 AccessKey Secret" kServiceVersion = "2020-06-01" ) var ( ServiceInfo = &base.ServiceInfo{ Timeout: 5 * time.Second, Host: "translate.volcengineapi.com", Header: http.Header{ "Accept": []string{"application/json"}, }, Credentials: base.Credentials{Region: base.RegionCnNorth1, Service: "translate"}, } ApiInfoList = map[string]*base.ApiInfo{ "LangDetect": { Method: http.MethodPost, Path: "/", Query: url.Values{ "Action": []string{"LangDetect"}, "Version": []string{kServiceVersion}, }, }, } ) func newClient() *base.Client { client := base.NewClient(ServiceInfo, ApiInfoList) client.SetAccessKey(kAccessKey) client.SetSecretKey(kSecretKey) return client } func main() { client := newClient() resp, code, err := client.Json("LangDetect", nil, `{"TextList":["你好世界"]}`) if err != nil { panic(err) } fmt.Printf("%d %s\n", code, string(resp)) } ``` -------------------------------- ### Speech Translation with Golang SDK Source: https://www.volcengine.com/docs/4640/127504 Uses vcloud-sdk-golang and gorilla/websocket to interact with the translation service. Includes helper functions for reading local audio files and constructing the service client. ```go package main import ( "bytes" "encoding/json" "io" "io/ioutil" "net/http" "net/url" "os" "sync" "time" "github.com/gorilla/websocket" "github.com/volcengine/volc-sdk-golang/base" ) const ( accessKey = "accessKey" // https://console.volcengine.com/iam/keymanage/ secretKey = "secretKey" ) const ( kServiceVersion20200601 = "2020-06-01" kSpeechTranslateAction = "SpeechTranslate" kHost = "translate.volces.com" ) func fromLocal(path string) (*bytes.Reader, error) { f, err := os.Open(path) if err != nil { return nil, err } defer f.Close() data, err := ioutil.ReadAll(f) if err != nil { return nil, err } return bytes.NewReader(data), nil } func newServiceInfo(host string) *base.ServiceInfo { return &base.ServiceInfo{ Timeout: 5 * time.Second, Host: host, Header: http.Header{}, Credentials: base.Credentials{Region: base.RegionCnNorth1, Service: "translate"}, } } func newClient(host string, accessKey string, secretKey string) *base.Client { client := base.NewClient(newServiceInfo(host), map[string]*base.ApiInfo{ kSpeechTranslateAction: { Method: http.MethodGet, Path: "/api/translate/speech/v1/", Query: url.Values{ "Action": []string{kSpeechTranslateAction}, "Version": []string{kServiceVersion20200601}, }, }, }) client.SetAccessKey(accessKey) client.SetSecretKey(secretKey) return client } func newAudioData(data []byte) []byte { type AudioDataReq struct { AudioData []byte `json:"AudioData"` } audioData := &AudioDataReq{ AudioData: data, } b, err := json.Marshal(audioData) if err != nil { println(err.Error()) return []byte{0} } return b } ``` -------------------------------- ### 使用 Python 调用文本语种检测API Source: https://www.volcengine.com/docs/4640/65066 使用 volc-sdk-python 进行语种检测的示例代码。需配置 AccessKey 和 SecretKey，并设置正确的服务信息。 ```python import json from volcengine.ApiInfo import ApiInfo from volcengine.Credentials import Credentials from volcengine.ServiceInfo import ServiceInfo from volcengine.base.Service import Service k_access_key = '密钥管理中的 AccessKey ID' # https://console.volcengine.com/iam/keymanage/ k_secret_key = '密钥管理中的 AccessKey Secret' k_timeout = 5 # second k_service_info = \ ServiceInfo('translate.volcengineapi.com', {'Content-Type': 'application/json'}, Credentials(k_access_key, k_secret_key, 'translate', 'cn-north-1'), 5, 5) k_query = { 'Action': 'LangDetect', 'Version': '2020-06-01' } k_api_info = { 'langdetect': ApiInfo('POST', '/', k_query, {}, {}) } service = Service(k_service_info, k_api_info) body = { 'TextList': ['Hello world', 'こんにちは世界'], } print(service.json('langdetect', {}, json.dumps(body))) ``` -------------------------------- ### Node.js WebSocket语音翻译客户端 Source: https://www.volcengine.com/docs/4640/127504 使用vcloud-sdk-nodejs和ws库，通过WebSocket连接调用SpeechTranslate API。需要配置访问密钥和音频文件audio.wav。发送配置后，以200*32字节块读取音频并发送，最后发送End信号。 ```typescript import {Signer} from "@volcengine/openapi"; import {Credentials, RequestObj} from "@volcengine/openapi/lib/base/types"; import WebSocket from 'ws'; import * as fs from 'fs'; import {open} from 'node:fs/promises'; import {sleep} from "@volcengine/openapi/lib/services/rocketmq/utils/common"; const host = "translate.volces.com" const path = "/api/translate/speech/v1/" function getWebsocketUrl(): string { const openApiRequestData: RequestObj = { method: "GET", region: "cn-north-1", params: { Action: "SpeechTranslate", Version: "2020-06-01", }, pathname: "/api/translate/speech/v1/" }; const credentials: Credentials = { accessKeyId: "your access key", secretKey: "your secret key", }; const signer = new Signer(openApiRequestData, "translate"); return 'wss://' + host + path + '?' + signer.getSignUrl(credentials); } console.log(getWebsocketUrl()); const ws = new WebSocket(getWebsocketUrl()); ws.on('open', async () => { console.log("onopen") let configuration = { "Configuration": { "SourceLanguage": "en", "TargetLanguages": [ "zh" ], "HotWordList": [ { "Word": "hello", "Scale": 1 } ], "Extra": {} } }; ws.send(JSON.stringify(configuration)); let readStream = fs.createReadStream('audio.wav'); readStream.on('readable', async () => { let chunk = readStream.read(200 * 32); while (chunk !== null) { await sleep(200).catch(e => { console.error(e); }) let audio = { "AudioData": Buffer.from(chunk).toString("base64") }; ws.send(JSON.stringify(audio)); chunk = readStream.read(200 * 32); } ws.send(JSON.stringify({ "End": true })); }) }); ws.on('message', (data) => { console.log("%s", data); }); ws.on("close", () => { console.log("onclose") }); ws.on("error", (err) => { console.error(err) }); ws.on("ping", () => { console.log("headers") }); ws.on("pong", () => { }); typescript ``` -------------------------------- ### WEBSOCKET wss://translate.volces.com/api/translate/speech/v1/ Source: https://www.volcengine.com/docs/4640/127504 实时语音翻译API集成语音识别、智能断句、文本翻译等技术能力，可以将实时语音流、音频文件识别成文字并翻译成目标语言，达到“边说边译”的效果。 ```APIDOC ## WEBSOCKET wss://translate.volces.com/api/translate/speech/v1/ ### Description 实时语音翻译API集成语音识别、智能断句、文本翻译等技术能力，可以将实时语音流、音频文件识别成文字并翻译成目标语言，达到“边说边译”的效果。 ### Method WEBSOCKET ### Endpoint wss://translate.volces.com/api/translate/speech/v1/ ### Authentication 使用火山引擎鉴权sdk，详情参照公共参数。 | 参数名 | 值 | |---|---| | Version | 2020-06-01 | | Action | SpeechTranslate | | Path | /api/translate/speech/v1/ | ### Request Body 服务使用websocket协议。 #### Configuration 建立websocket之后第一包发送配置包如下： | 字段 | 类型 | 是否为必须项 | 说明 | 备注 | |---|---|---|---|---| | SourceLanguage | String | 是 | 源语言 | 仅支持zh ja en | | TargetLanguages | [String] | 是 | 目标语言 | 对齐文本翻译支持列表：语言支持 | | HotWordList | [Object] | 否 | 热词 | 在语音识别时，接口更倾向于识别成热词的内容 | ```json { "Configuration": { "SourceLanguage": "zh", "TargetLanguages": [ "en" ], "HotWordList": [ { "Word": "hello", "Scale": 1 } ] } } ``` #### AudioData 发送Configuratoin之后可以发送二进制数组的音频数据包，采样率为16000hz，单声道，使用base64编码，推荐每100-200ms发送一包。 | 字段 | 类型 | 是否为必须项 | 说明 | 备注 | |---|---|---|---|---| | AudioData | String | 是 | 音频包的base64编码 | 无 | ```json { "AudioData": "YQ==" } ``` #### End bool值，只要发送了就表示音频发送结束。 | 字段 | 类型 | 是否为必须项 | 说明 | 备注 | |---|---|---|---|---| | End | Bool | 是 | 音频包发送完成时发 | 不论true，false，server接收到包后会处理完剩余的音频包以及相关的翻译，全部结束后会断开websocket | ```json { "End": true } ``` ### Response #### Success Response | 字段 | 类型 | 说明 | 备注 | |---|---|---|---| | ResponseMetadata | ResponseMetadata | 通用字段 | 无 | | Subtitle | Object | 包含翻译结果、时间、语言等信息的结果 | 无 | Subtitle字段： | 字段 | 类型 | 说明 | 备注 | |---|---|---|---| | Text | String | 返回的结果 | 当某两个结果的Sequence和Definite一致时，结果中的Text分别代表原文及其译文 | | BeginTime | Int | 该文本识别的开始时间 | 无 | | EndTime | Int | 该文本识别的结束时间 | 无 | | Definite | Bool | 文本是否确定 | true：语音已结束；false：语音进行中 | | Language | String | 语言 | 无 | | Sequence | Int | 序列号 | 文本片段的序号 | ```json { "Subtitle": { "Text": "i'm elise hugh this is ted talk daily", "BeginTime": 4070, "EndTime": 6955, "Definite": false, "Language": "en", "Sequence": 8 }, "ResponseMetaData": { "RequestId": "7088303501725501476", "Action": "SpeechTranslate", "Version": "2020-06-01", "Service": "translate", "Region": "cn-north-1" } } ``` #### Error Response 在接口错误时，错误信息会在ResponseMetadata.Error中，包含了错误类型Code:: String和错误信息Message:: String两个字段。 | 错误码 | 说明 | |---|---| | -301 | 音频间隔过长 | | -400 | 请求参数错误，具体错误可参考Message信息 | | -401 | 未授权用户 | | -403 | 无权限 | | -429 | 请求过于频繁 | | -5xx | 翻译引擎内部错误 | | 100001-100021 | 通用错误 | ### Audio Requirements - 采样率：16000hz - 采样位：16 - 单声道 - 格式：wav或pcm（格式错误会导致识别效果差，返回时间戳错误等一系列问题，所以一定要确保自己发送的格式正确。） - 音频内容需使用base64编码 ``` -------------------------------- ### TranslateImage API with Python Source: https://www.volcengine.com/docs/4640/65105 Uses the volc-sdk-python to translate an image. Requires setting your AccessKey ID and Secret Key from the Volcengine console. ```python import json import requests import base64 import time from volcengine.ApiInfo import ApiInfo from volcengine.Credentials import Credentials from volcengine.ServiceInfo import ServiceInfo from volcengine.base.Service import Service # 示例图片url img_url = 'https://s1.ax1x.com/2020/07/07/UAtqnf.png' k_access_key = '密钥管理中的 AccessKey ID' # https://console.volcengine.com/iam/keymanage/ k_secret_key = '密钥管理中的 AccessKey Secret' k_timeout = 5 # second k_service_info = \ ServiceInfo('translate.volcengineapi.com', {'Content-Type': 'application/json'}, Credentials(k_access_key, k_secret_key, 'translate', 'cn-north-1'), 5, 5) k_query = { 'Action': 'TranslateImage', 'Version': '2020-07-01' } k_api_info = { 'translate': ApiInfo('POST', '/', k_query, {}, {}) } service = Service(k_service_info, k_api_info) img_data = requests.get(img_url).content img_base64 = str(base64.b64encode(img_data), encoding='utf8') body = { 'Image': img_base64, 'TargetLanguage': "zh"} res_data = service.json('translate', {}, json.dumps(body)) print(res_data) ``` -------------------------------- ### Submit and query audio translation task with volc-sdk-python Source: https://www.volcengine.com/docs/4640/78985 Uses the volc-sdk-python dependency to submit an audio translation task and poll for its result. Requires valid AccessKey ID and Secret from the Volcengine IAM console. The script prints the task ID, then polls every 60 seconds until the status becomes 'success', printing each subtitle's timing, text, and translation. ```python import json import time from volcengine.ApiInfo import ApiInfo from volcengine.Credentials import Credentials from volcengine.ServiceInfo import ServiceInfo from volcengine.base.Service import Service k_access_key = '密钥管理中的 AccessKey ID' # https://console.volcengine.com/iam/keymanage/ k_secret_key = '密钥管理中的 AccessKey Secret' k_timeout = 5 # second k_service_info = \ ServiceInfo('translate.volcengineapi.com', {'Content-Type': 'application/json'}, Credentials(k_access_key, k_secret_key, 'translate', 'cn-north-1'), 5, 5) k_api_info = { 'submit_audio': ApiInfo('POST', '/', { 'Action': 'SubmitAudio', 'Version': '2020-06-01' }, {}, {}), 'query_audio': ApiInfo('POST', '/', { 'Action': 'QueryAudio', 'Version': '2020-06-01' }, {}, {}), } service = Service(k_service_info, k_api_info) # 提交任务 submit_body = { 'SourceLanguage': 'en', 'TargetLanguage': 'zh', 'Uri': "http://xx/xx.mp4", } submit_result = json.loads(service.json('submit_audio', {}, json.dumps(submit_body))) task_id = submit_result["TaskId"] print(task_id) # 查询任务 status = "created" while status == "created": time.sleep(60) query_body = { 'TaskId': task_id, } query_result = json.loads(service.json('query_audio', {}, json.dumps(query_body))) status = query_result["Status"] print(status) if status == "success": for subtitle in query_result["Subtitles"]: print("{} - {}: {} -> {}".format(subtitle["StartTime"], subtitle["EndTime"], subtitle["Text"], subtitle["Translation"])) ``` -------------------------------- ### TranslateImage API with Go Source: https://www.volcengine.com/docs/4640/65105 Uses the volc-sdk-golang to translate an image. Requires configuring the ServiceInfo and ApiInfoList with your credentials. ```golang package main import ( "encoding/base64" "encoding/json" "fmt" "io/ioutil" "net/http" "net/url" "time" "github.com/volcengine/volc-sdk-golang/base" ) const ( kAccessKey = "密钥管理中的 AccessKey ID" // https://console.volcengine.com/iam/keymanage/ kSecretKey = "密钥管理中的 AccessKey Secret" kServiceVersion = "2020-07-01" // 示例图片url imgUrl = "https://s1.ax1x.com/2020/07/07/UAtqnf.png" ) var ( ServiceInfo = &base.ServiceInfo{ Timeout: 5 * time.Second, Host: "translate.volcengineapi.com", Header: http.Header{ "Accept": []string{"application/json"}, }, Credentials: base.Credentials{Region: base.RegionCnNorth1, Service: "translate"}, } ApiInfoList = map[string]*base.ApiInfo{ "TranslateImage": { Method: http.MethodPost, Path: "/", Query: url.Values{ "Action": []string{"TranslateImage"}, "Version": []string{kServiceVersion}, }, }, } ) func newClient() *base.Client { client := base.NewClient(ServiceInfo, ApiInfoList) client.SetAccessKey(kAccessKey) client.SetSecretKey(kSecretKey) return client } func main() { imgRes, _ := http.Get(imgUrl) defer imgRes.Body.Close() imgData, _ := ioutil.ReadAll(imgRes.Body) imgBase64 := base64.StdEncoding.EncodeToString(imgData) jsonBody := map[string]string{ "Image": imgBase64, "TargetLanguage": "zh"} body, _ := json.Marshal(jsonBody) client := newClient() res, code, err := client.Json("TranslateImage", nil, string(body)) if err != nil { panic(err) } fmt.Printf("%d %s\n", code, string(res)) } ``` -------------------------------- ### Java: Maven dependencies for WebSocket speech translation Source: https://www.volcengine.com/docs/4640/127504 Maven pom.xml snippet listing required dependencies for using Java WebSocket client, SLF4J logging, and the Volcengine Java SDK. Placeholders like {version} must be replaced with actual versions. ```xml javax.websocket javax.websocket-client-api {version} org.java-websocket Java-WebSocket 1{version} org.slf4j slf4j-simple {version} runtime org.slf4j slf4j-api {version} com.volcengine volc-sdk-java {version} ``` -------------------------------- ### TranslateConfig.java - Configure Speech Translate API Source: https://www.volcengine.com/docs/4640/127504 Defines access keys, API name, path, host, and service info for the Volcengine Speech Translate API. Sets connection and socket timeouts, headers, credentials, and API method/path/query parameters. ```java //src/main/java/translate/TranslateConfig.java package translate; import com.volcengine.helper.Const; import com.volcengine.model.ApiInfo; import com.volcengine.model.Credentials; import com.volcengine.model.ServiceInfo; import org.apache.http.Header; import org.apache.http.NameValuePair; import org.apache.http.message.BasicHeader; import org.apache.http.message.BasicNameValuePair; import java.util.ArrayList; import java.util.HashMap; import java.util.Map; public class TranslateConfig { public static String accessKey = "your access key"; public static String secretKey = "your secret key"; public static String api = "SpeechTranslate"; public static String path = "/api/translate/speech/v1/"; public static String host = "translate.volces.com"; public static ServiceInfo serviceInfo = new ServiceInfo( new HashMap<>() { { put(Const.CONNECTION_TIMEOUT, 5000); put(Const.SOCKET_TIMEOUT, 5000); put(Const.Host, host); put(Const.Header, new ArrayList
() { { add(new BasicHeader("Accept", "application/json")); } }); put(Const.Credentials, new Credentials(Const.REGION_CN_NORTH_1, "translate")); } } ); public static Map apiInfoList = new HashMap<>() { { put(api, new ApiInfo( new HashMap<>() { { put(Const.Method, "GET"); put(Const.Path, path); put(Const.Query, new ArrayList() { { add(new BasicNameValuePair("Action", api)); add(new BasicNameValuePair("Version", "2020-06-01")); } }); } } )); } }; } ``` -------------------------------- ### TranslateImage API with Java Source: https://www.volcengine.com/docs/4640/65105 Snippet for using the volc-sdk-java to perform image translation. Assumes an existing translateService instance. ```java // byte[] input = new byte[10]; // read file String base64Image = Base64.getEncoder().encodeToString(input); TranslateImageRequest translateImageRequest = new TranslateImageRequest(); translateImageRequest.setTargetLanguage("zh"); translateImageRequest.setImage(base64Image); TranslateImageResponse translateImageResponse = translateService.translateImage(translateImageRequest); System.out.println(JSON.toJSONString(translateImageResponse.getResponseMetadata())); System.out.println(JSON.toJSONString(translateImageResponse.getResult())); byte[] output = Base64.getDecoder().decode(translateImageResponse.getImage()); // write file ``` -------------------------------- ### POST /submit-audio-translation-task Source: https://www.volcengine.com/docs/4640/78985 Submits an audio/video file translation task. This is the first step of the audio/video file translation API, which integrates speech recognition, intelligent sentence segmentation, and machine translation to process audio/video files. ```APIDOC ## POST /submit-audio-translation-task ### Description Submits an audio/video file translation task. This is the first step of the audio/video file translation API, which integrates speech recognition, intelligent sentence segmentation, and machine translation to process audio/video files. ### Method POST ### Endpoint Not specified in the source. The API is invoked via a POST request with the request body described below. ### Parameters #### Request Body - **SourceLanguage** (String) - Required - Source language. Supported values: en, zh, ko. - **TargetLanguage** (String) - Required - Target language. Supported values: en, zh, ko, ja, pt, fr, de, es. - **Uri** (String) - Required - URL of the video/audio file to be translated. It is recommended to use with video-on-demand service to avoid server-side download failures. ### Request Example { "SourceLanguage": "en", "TargetLanguage": "zh", "Uri": "http://xx/xx.mp4" } ### Response #### Success Response (200) - **ResponseMetadata** (ResponseMetadata) - Common metadata. - **TaskId** (String) - Task ID for querying the result later. #### Response Example { "TaskId": "asdasda", "ResponseMetadata": { "RequestId": "202004092306480100140440781F5D7119", "Action": "SubmitAudio", "Version": "2020-06-01", "Service": "translate", "Region": "cn-north-1", "Error": null } } ``` -------------------------------- ### Speech Translation with Python SDK Source: https://www.volcengine.com/docs/4640/127504 Uses volc-sdk-python and websocket-client to stream audio data to the translation service. Requires valid access and secret keys from the Volcengine console. ```python # 需要引入https://github.com/volcengine/volc-sdk-python import base64 import json import threading import time import websocket from volcengine.ApiInfo import ApiInfo from volcengine.Credentials import Credentials from volcengine.ServiceInfo import ServiceInfo from volcengine.base.Service import Service k_access_key = "k_access_key" # https://console.volcengine.com/iam/keymanage/ k_secret_key = "k_secret_key" k_host = 'translate.volces.com' k_path = '/api/translate/speech/v1/' k_timeout = 5 # second k_service_info = \ ServiceInfo(k_host, {'Content-Type': 'application/json'}, Credentials(k_access_key, k_secret_key, 'translate', 'cn-north-1'), 5, 5) k_query = { 'Action': 'SpeechTranslate', 'Version': '2020-06-01' } k_api_info = { 'SpeechTranslate': ApiInfo('GET', k_path, k_query, {}, {}) } file_path = './audio.wav' # 音频的文件 def get_websocket_url(): service = Service(k_service_info, k_api_info) url = 'wss://' + k_host + k_path + '?' + service.get_sign_url("SpeechTranslate", {}) return url def send_audio(ws): file = open(file_path, 'rb') while True: chunk = file.read(200 * 32) if not chunk: break audio = { "AudioData": base64.b64encode(chunk).decode('utf-8') } ws.send(json.dumps(audio)) time.sleep(0.2) end = { "End": True } ws.send(json.dumps(end)) def recv(ws): while True: print(ws.recv().decode("utf-8")) if __name__ == '__main__': websocket.enableTrace(False) ws = websocket.WebSocket() ws.connect(get_websocket_url(), header=["Content-Type: application/json"]) configuration = { "Configuration": { "SourceLanguage": "zh", "TargetLanguages": [ "en" ], "HotWordList": [ { "Word": "hello", "Scale": 1 } ] } } ws.send(json.dumps(configuration)) t2 = threading.Thread(target=recv, args=(ws,)) t1 = threading.Thread(target=send_audio, args=(ws,)) t2.start() t1.start() ``` -------------------------------- ### 提交音视频翻译任务请求与响应 Source: https://www.volcengine.com/docs/4640/78985 提交翻译任务的请求体包含源语言、目标语言和文件链接，响应返回任务ID。 ```json { "SourceLanguage": "en", "TargetLanguage": "zh", "Uri": "http://xx/xx.mp4" } ``` ```json { "TaskId": "asdasda", "ResponseMetadata": { "RequestId": "202004092306480100140440781F5D7119", "Action": "SubmitAudio", "Version": "2020-06-01", "Service": "translate", "Region": "cn-north-1", "Error": null } } ``` -------------------------------- ### 文本语种检测API 请求与返回样例 Source: https://www.volcengine.com/docs/4640/65066 展示了调用文本语种检测接口的JSON请求体格式以及对应的返回体结构，包含语言代码和置信度信息。 ```json { "TextList": [ "Hello world" ] } ``` ```json { "DetectedLanguageList": [ { "Language": "en", "Confidence": 1 } ], "ResponseMetadata": { "RequestId": "202004092241580100140440770840151B", "Action": "LangDetect", "Version": "2020-06-01", "Service": "translate", "Region": "cn-north-1", "Error": null } } ``` -------------------------------- ### Client.java - WebSocket Client for Speech Translate Source: https://www.volcengine.com/docs/4640/127504 Implements a WebSocket client that prints connection events and received messages. Handles both text and binary messages, and prints errors. ```java // src/main/java/websocket/Client.java package websocket; import org.java_websocket.client.WebSocketClient; import org.java_websocket.handshake.ServerHandshake; import java.net.URI; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; public class Client extends WebSocketClient { public Client(URI serverUri) { super(serverUri); } @Override public void onOpen(ServerHandshake serverHandshake) { System.out.println("onopen"); } @Override public void onMessage(String s) { System.out.println("onmessage"); System.out.println(s); } @Override public void onMessage(ByteBuffer message) { System.out.println("onmessage"); System.out.println(new String(message.array(), StandardCharsets.UTF_8)); } @Override public void onClose(int i, String s, boolean b) { System.out.println("onclose"); } @Override public void onError(Exception e) { e.printStackTrace(); } } ``` -------------------------------- ### TranslateService.java - Extend BaseServiceImpl Source: https://www.volcengine.com/docs/4640/127504 Defines a service class that extends BaseServiceImpl, taking ServiceInfo and API info map as constructor arguments. Used to interact with the Volcengine Speech Translate API. ```java // src/main/java/translate/TranslateService.java package translate; import com.volcengine.model.ApiInfo; import com.volcengine.model.ServiceInfo; import com.volcengine.service.BaseServiceImpl; import java.util.Map; public class TranslateService extends BaseServiceImpl { public TranslateService(ServiceInfo info, Map apiInfoList) { super(info, apiInfoList); } } ``` -------------------------------- ### POST / Source: https://www.volcengine.com/docs/4640/65066 Detects the language of the provided text list. Supports 140 languages and returns the most reliable result. ```APIDOC ## POST / ### Description Detects the language of the provided text list. Supports 140 languages and returns the most reliable result. ### Method POST ### Endpoint / ### Parameters #### Request Body - **TextList** ([String]) - Required - The list of texts to detect. List length must not exceed 16. ### Request Example { "TextList": [ "Hello world" ] } ### Response #### Success Response (200) - **ResponseMetadata** (ResponseMetadata) - Common fields. - **DetectedLanguageList** ([DetectedLanguage]) - List of detected languages. - **Language** (String) - Detection result. - **Confidence** (Double) - Confidence score, range 0-1; higher means more reliable. #### Response Example { "DetectedLanguageList": [ { "Language": "en", "Confidence": 1 } ], "ResponseMetadata": { "RequestId": "202004092241580100140440770840151B", "Action": "LangDetect", "Version": "2020-06-01", "Service": "translate", "Region": "cn-north-1", "Error": null } } ``` -------------------------------- ### Java 音频翻译任务提交与查询 Source: https://www.volcengine.com/docs/4640/78985 该示例演示了创建翻译任务、等待处理以及根据任务 ID 查询翻译结果的完整调用流程。 ```java // 提交任务，获取任务ID TranslateAudioSubmitRequest translateAudioSubmitRequest = new TranslateAudioSubmitRequest(); translateAudioSubmitRequest.setSourceLanguage("en"); translateAudioSubmitRequest.setTargetLanguage("zh"); translateAudioSubmitRequest.setUri("http://xx/xx.mp4"); TranslateAudioSubmitResponse translateAudioSubmitResponse = translateService.translateAudioSubmit(translateAudioSubmitRequest); System.out.println(JSON.toJSONString(translateAudioSubmitResponse)); // 等待任务完成 Thread.sleep(5000); // 视频时长*0.3 // 查询结果 TranslateAudioQueryRequest translateAudioQueryRequest = new TranslateAudioQueryRequest(); translateAudioQueryRequest.setTaskId(translateAudioSubmitResponse.getTaskId()); TranslateAudioQueryResponse translateAudioQueryResponse = translateService.translateAudioQuery(translateAudioQueryRequest); System.out.println(JSON.toJSONString(translateAudioQueryResponse)); ```