实时语音识别

import com.alibaba.dashscope.audio.asr.recognition.Recognition;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionParam;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionResult;
import com.alibaba.dashscope.common.ResultCallback;
import com.alibaba.dashscope.utils.Constants;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.TargetDataLine;

import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Main {
  public static void main(String[] args) throws InterruptedException {
    Constants.baseWebsocketApiUrl = "wss://dashscope.aliyuncs.com/api-ws/v1/inference";
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    executorService.submit(new RealtimeRecognitionTask());
    executorService.shutdown();
    executorService.awaitTermination(1, TimeUnit.MINUTES);
    System.exit(0);
  }
}

class RealtimeRecognitionTask implements Runnable {
  @Override
  public void run() {
    RecognitionParam param = RecognitionParam.builder()
        .model("fun-asr-realtime")
        // 如果未配置环境变量，请将下一行替换为您的 API Key：.apiKey("sk-xxx")
        .apiKey(System.getenv("DASHSCOPE_API_KEY"))
        .format("wav")
        .sampleRate(16000)
        .build();
    Recognition recognizer = new Recognition();

    ResultCallback<RecognitionResult> callback = new ResultCallback<RecognitionResult>() {
      @Override
      public void onEvent(RecognitionResult result) {
        if (result.isSentenceEnd()) {
          System.out.println("Final Result: " + result.getSentence().getText());
        } else {
          System.out.println("Intermediate Result: " + result.getSentence().getText());
        }
      }

      @Override
      public void onComplete() {
        System.out.println("Recognition complete");
      }

      @Override
      public void onError(Exception e) {
        System.out.println("RecognitionCallback error: " + e.getMessage());
      }
    };
    try {
      recognizer.call(param, callback);
      // 创建音频格式
      AudioFormat audioFormat = new AudioFormat(16000, 16, 1, true, false);
      // 根据格式匹配默认录音设备
      TargetDataLine targetDataLine =
          AudioSystem.getTargetDataLine(audioFormat);
      targetDataLine.open(audioFormat);
      // 开始录音
      targetDataLine.start();
      ByteBuffer buffer = ByteBuffer.allocate(1024);
      long start = System.currentTimeMillis();
      // 录制 50 秒并实时转写
      while (System.currentTimeMillis() - start < 50000) {
        int read = targetDataLine.read(buffer.array(), 0, buffer.capacity());
        if (read > 0) {
          buffer.limit(read);
          // 将录制的音频数据发送至流式识别服务
          recognizer.sendAudioFrame(buffer);
          buffer = ByteBuffer.allocate(1024);
          // 限制录音速率，短暂休眠以防止 CPU 占用过高
          Thread.sleep(20);
        }
      }
      recognizer.stop();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      // 任务完成后关闭 WebSocket 连接
      recognizer.getDuplexApi().close(1000, "bye");
    }

    System.out.println(
        "[Metric] requestId: "
            + recognizer.getLastRequestId()
            + ", first package delay ms: "
            + recognizer.getFirstPackageDelay()
            + ", last package delay ms: "
            + recognizer.getLastPackageDelay());
  }
}

import com.alibaba.dashscope.api.GeneralApi;
import com.alibaba.dashscope.audio.asr.recognition.Recognition;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionParam;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionResult;
import com.alibaba.dashscope.base.HalfDuplexParamBase;
import com.alibaba.dashscope.common.GeneralListParam;
import com.alibaba.dashscope.common.ResultCallback;
import com.alibaba.dashscope.protocol.GeneralServiceOption;
import com.alibaba.dashscope.protocol.HttpMethod;
import com.alibaba.dashscope.protocol.Protocol;
import com.alibaba.dashscope.protocol.StreamingMode;
import com.alibaba.dashscope.utils.Constants;

import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class TimeUtils {
  private static final DateTimeFormatter formatter =
      DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");

  public static String getTimestamp() {
    return LocalDateTime.now().format(formatter);
  }
}

public class Main {
  public static void main(String[] args) throws InterruptedException {
    Constants.baseWebsocketApiUrl = "wss://dashscope.aliyuncs.com/api-ws/v1/inference";
    // 在实际应用中，仅在程序启动时调用一次此方法
    warmUp();

    ExecutorService executorService = Executors.newSingleThreadExecutor();
    executorService.submit(new RealtimeRecognitionTask(Paths.get(System.getProperty("user.dir"), "asr_example.wav")));
    executorService.shutdown();

    // 等待所有任务完成
    executorService.awaitTermination(1, TimeUnit.MINUTES);
    System.exit(0);
  }

  public static void warmUp() {
    try {
      // 使用轻量级 GET 请求预建连接
      GeneralServiceOption warmupOption = GeneralServiceOption.builder()
          .protocol(Protocol.HTTP)
          .httpMethod(HttpMethod.GET)
          .streamingMode(StreamingMode.OUT)
          .path("assistants")
          .build();

      warmupOption.setBaseHttpUrl(Constants.baseHttpApiUrl);
      GeneralApi<HalfDuplexParamBase> api = new GeneralApi<>();
      api.get(GeneralListParam.builder().limit(1L).build(), warmupOption);
    } catch (Exception e) {
      // 预热失败时允许重试
    }
  }
}

class RealtimeRecognitionTask implements Runnable {
  private Path filepath;

  public RealtimeRecognitionTask(Path filepath) {
    this.filepath = filepath;
  }

  @Override
  public void run() {
    RecognitionParam param = RecognitionParam.builder()
        .model("fun-asr-realtime")
        // 如果未配置环境变量，请将下一行替换为您的 API Key：.apiKey("sk-xxx")
        .apiKey(System.getenv("DASHSCOPE_API_KEY"))
        .format("wav")
        .sampleRate(16000)
        .build();
    Recognition recognizer = new Recognition();

    String threadName = Thread.currentThread().getName();

    ResultCallback<RecognitionResult> callback = new ResultCallback<RecognitionResult>() {
      @Override
      public void onEvent(RecognitionResult message) {
        if (message.isSentenceEnd()) {

          System.out.println(TimeUtils.getTimestamp()+" "+
              "[process " + threadName + "] Final Result:" + message.getSentence().getText());
        } else {
          System.out.println(TimeUtils.getTimestamp()+" "+
              "[process " + threadName + "] Intermediate Result: " + message.getSentence().getText());
        }
      }

      @Override
      public void onComplete() {
        System.out.println(TimeUtils.getTimestamp()+" "+"[" + threadName + "] Recognition complete");
      }

      @Override
      public void onError(Exception e) {
        System.out.println(TimeUtils.getTimestamp()+" "+
            "[" + threadName + "] RecognitionCallback error: " + e.getMessage());
      }
    };

    try {
      recognizer.call(param, callback);
      // 请将路径替换为您的音频文件路径
      System.out.println(TimeUtils.getTimestamp()+" "+"[" + threadName + "] Input file_path is: " + this.filepath);
      // 读取文件并分块发送音频
      FileInputStream fis = new FileInputStream(this.filepath.toFile());
      byte[] allData = new byte[fis.available()];
      int ret = fis.read(allData);
      fis.close();

      int sendFrameLength = 3200;
      for (int i = 0; i * sendFrameLength < allData.length; i ++) {
        int start = i * sendFrameLength;
        int end = Math.min(start + sendFrameLength, allData.length);
        ByteBuffer byteBuffer = ByteBuffer.wrap(allData, start, end - start);
        recognizer.sendAudioFrame(byteBuffer);
        Thread.sleep(100);
      }

      System.out.println(TimeUtils.getTimestamp()+" "+LocalDateTime.now());
      recognizer.stop();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      // 任务完成后关闭 WebSocket 连接
      recognizer.getDuplexApi().close(1000, "bye");
    }

    System.out.println(
        "["
            + threadName
            + "][Metric] requestId: "
            + recognizer.getLastRequestId()
            + ", first package delay ms: "
            + recognizer.getFirstPackageDelay()
            + ", last package delay ms: "
            + recognizer.getLastPackageDelay());
  }
}

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

# pip install websocket-client
import os
import json
import time
import uuid
import threading
import websocket

# 若没有配置环境变量，请用 API Key 将下行替换为：api_key = "sk-xxx"
api_key = os.environ.get('DASHSCOPE_API_KEY')
url = 'wss://dashscope.aliyuncs.com/api-ws/v1/inference/'
audio_file = 'asr_example.wav'  # 替换为您的音频文件路径

TASK_ID = uuid.uuid4().hex[:32]
task_started = False

def send_run_task(ws):
  run_task_message = {
    'header': {
      'action': 'run-task',
      'task_id': TASK_ID,
      'streaming': 'duplex'
    },
    'payload': {
      'task_group': 'audio',
      'task': 'asr',
      'function': 'recognition',
      'model': 'fun-asr-realtime',
      'parameters': {
        'sample_rate': 16000,
        'format': 'wav'
      },
      'input': {}
    }
  }
  ws.send(json.dumps(run_task_message))

def send_finish_task(ws):
  finish_task_message = {
    'header': {
      'action': 'finish-task',
      'task_id': TASK_ID,
      'streaming': 'duplex'
    },
    'payload': {
      'input': {}
    }
  }
  ws.send(json.dumps(finish_task_message))

def send_audio_stream(ws):
  chunk_size = 3200  # 100ms @ 16kHz 16bit 单声道
  try:
    with open(audio_file, 'rb') as f:
      while True:
        chunk = f.read(chunk_size)
        if not chunk:
          break
        ws.send(chunk, opcode=websocket.ABNF.OPCODE_BINARY)
        time.sleep(0.1)
    print('音频流结束')
    send_finish_task(ws)
  except Exception as e:
    print('读取音频文件错误：', e)
    ws.close()

def on_open(ws):
  print('连接到服务器')
  send_run_task(ws)

def on_message(ws, data):
  global task_started
  message = json.loads(data)
  event = message['header']['event']
  if event == 'task-started':
    print('任务开始')
    task_started = True
    threading.Thread(target=send_audio_stream, args=(ws,), daemon=True).start()
  elif event == 'result-generated':
    print('识别结果：', message['payload']['output']['sentence']['text'])
    if message['payload'].get('usage'):
      print('任务计费时长（秒）：', message['payload']['usage']['duration'])
  elif event == 'task-finished':
    print('任务完成')
    ws.close()
  elif event == 'task-failed':
    print('任务失败：', message['header'].get('error_message'))
    ws.close()
  else:
    print('未知事件：', event)

def on_close(ws, close_status_code, close_msg):
  if not task_started:
    print('任务未启动，关闭连接')

def on_error(ws, error):
  print('WebSocket错误：', error)

if __name__ == '__main__':
  ws = websocket.WebSocketApp(
    url,
    header={'Authorization': f'bearer {api_key}'},
    on_open=on_open,
    on_message=on_message,
    on_error=on_error,
    on_close=on_close
  )
  ws.run_forever()