如何优雅地结束 Google Speech-to-Text 流识别并取回待处理的文本结果？

我希望能够结束 Google 语音转文本流（创建于streamingRecognize），并获取待处理的 SR（语音识别）结果。

简而言之，相关的 Node.js 代码：

// create SR stream
const stream = speechClient.streamingRecognize(request);

// observe data event
const dataPromise = new Promise(resolve => stream.on('data', resolve));

// observe error event
const errorPromise = new Promise((resolve, reject) => stream.on('error', reject));

// observe finish event
const finishPromise = new Promise(resolve => stream.on('finish', resolve));

// send the audio
stream.write(audioChunk);

// for testing purposes only, give the SR stream 2 seconds to absorb the audio
await new Promise(resolve => setTimeout(resolve, 2000));

// end the SR stream gracefully, by observing the completion callback
const endPromise = util.promisify(callback => stream.end(callback))();

// a 5 seconds test timeout
const timeoutPromise = new Promise(resolve => setTimeout(resolve, 5000)); 

// finishPromise wins the race here
await Promise.race([
  dataPromise, errorPromise, finishPromise, endPromise, timeoutPromise]);

// endPromise wins the race here
await Promise.race([
  dataPromise, errorPromise, endPromise, timeoutPromise]);

// timeoutPromise wins the race here
await Promise.race([dataPromise, errorPromise, timeoutPromise]);

// I don't see any data or error events, dataPromise and errorPromise don't get settled

我的经历是 SR 流成功结束，但我没有收到任何数据事件或错误事件。两者都不dataPromise nor errorPromise得到解决或拒绝。

如何发出音频结束信号、关闭 SR 流并仍然获得待处理的 SR 结果？

我需要坚持streamingRecognize API因为我正在流式传输的音频是实时的，即使它可能会突然停止。

澄清一下，只要我继续传输音频，它就可以工作，我确实会收到实时 SR 结果。但是，当我发送最终音频块并像上面那样结束流时，我不会得到我期望的最终结果。

为了得到最终结果，我实际上必须再保持流静默几秒钟，这可能会增加 ST 费用。我觉得一定有更好的方法来获得它们。

Updated:看来，结束一场战争的唯一合适时机streamingRecognize溪流即将来临data活动地点StreamingRecognitionResult.is_final is true。此外，我们预计将继续传输音频，直到data事件被触发，以获得任何结果，最终的或临时的。

这对我来说看起来像是一个错误，提交了一个issue.

Updated:现在看来已经得到证实as a bug。在修复之前，我正在寻找潜在的解决方法。

Updated:以供将来参考，这是清单当前和之前跟踪的问题涉及streamingRecognize.

我希望这对于那些使用的人来说是一个常见问题streamingRecognize，很惊讶以前没有报道过。正在提交as a bug to issuetracker.google.com，还有。

我的错——毫不奇怪，这变成了我的代码中一个模糊的竞争条件。

我已经整理了一个独立的示例，可以按预期工作（gist）。它帮助我追踪问题。希望它可以帮助其他人和我未来的自己：

// A simple streamingRecognize workflow,
// tested with Node v15.0.1, by @noseratio

import fs from 'fs';
import path from "path";
import url from 'url'; 
import util from "util";
import timers from 'timers/promises';
import speech from '@google-cloud/speech';

export {}

// need a 16-bit, 16KHz raw PCM audio 
const filename = path.join(path.dirname(url.fileURLToPath(import.meta.url)), "sample.raw");
const encoding = 'LINEAR16';
const sampleRateHertz = 16000;
const languageCode = 'en-US';

const request = {
  config: {
    encoding: encoding,
    sampleRateHertz: sampleRateHertz,
    languageCode: languageCode,
  },
  interimResults: false // If you want interim results, set this to true
};

// init SpeechClient
const client = new speech.v1p1beta1.SpeechClient();
await client.initialize();

// Stream the audio to the Google Cloud Speech API
const stream = client.streamingRecognize(request);

// log all data
stream.on('data', data => {
  const result = data.results[0];
  console.log(`SR results, final: ${result.isFinal}, text: ${result.alternatives[0].transcript}`);
});

// log all errors
stream.on('error', error => {
  console.warn(`SR error: ${error.message}`);
});

// observe data event
const dataPromise = new Promise(resolve => stream.once('data', resolve));

// observe error event
const errorPromise = new Promise((resolve, reject) => stream.once('error', reject));

// observe finish event
const finishPromise = new Promise(resolve => stream.once('finish', resolve));

// observe close event
const closePromise = new Promise(resolve => stream.once('close', resolve));

// we could just pipe it: 
// fs.createReadStream(filename).pipe(stream);
// but we want to simulate the web socket data

// read RAW audio as Buffer
const data = await fs.promises.readFile(filename, null);

// simulate multiple audio chunks
console.log("Writting...");
const chunkSize = 4096;
for (let i = 0; i < data.length; i += chunkSize) {
  stream.write(data.slice(i, i + chunkSize));
  await timers.setTimeout(50);
}
console.log("Done writing.");

console.log("Before ending...");
await util.promisify(c => stream.end(c))();
console.log("After ending.");

// race for events
await Promise.race([
  errorPromise.catch(() => console.log("error")), 
  dataPromise.then(() => console.log("data")),
  closePromise.then(() => console.log("close")),
  finishPromise.then(() => console.log("finish"))
]);

console.log("Destroying...");
stream.destroy();
console.log("Final timeout...");
await timers.setTimeout(1000);
console.log("Exiting.");

输出：

Writting...
Done writing.
Before ending...
SR results, final: true, text:  this is a test I'm testing voice recognition This Is the End
After ending.
data
finish
Destroying...
Final timeout...
close
Exiting.
  

要测试它，需要 16 位/16KHz 原始 PCM 音频文件。任意 WAV 文件无法按原样工作，因为它包含带有元数据的标头。