/// <summary>
///
/// </summary>
/// <param name="encoding"></param>
/// <param name="sampleRateHertz"></param>
/// <param name="languageCode"></param>
/// <param name="intermResults"></param>
public async Task ConfigureSpeechRequest(
RecognitionConfig.Types.AudioEncoding encoding,
int sampleRateHertz,
string languageCode,
bool intermResults)
{
if (null == speechClient)
{
return;
}
streamingCall = speechClient.StreamingRecognize();
request = new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding = encoding,
SampleRateHertz = sampleRateHertz,
LanguageCode = languageCode,
},
InterimResults = intermResults,
}
};
// Write the initial request with the config.
await streamingCall.WriteAsync(request);
}
/// <summary>
/// Asynchronously sends chunks of audio to the server.
/// </summary>
/// <param name="call">Bidirectional streaming call whose request stream to write to.</param>
static async Task SendChunks(AsyncDuplexStreamingCall <StreamingRecognizeRequest, StreamingRecognizeResponse> call)
{
while (!m_DoneStreaming)
{
if (m_AudioChunksQueue.Count > 0)
{
var audioRequest = new StreamingRecognizeRequest();
audioRequest.AudioContent = m_AudioChunksQueue.Dequeue();
await call.RequestStream.WriteAsync(audioRequest);
}
await Task.Delay(k_MillisecondsBetweenChunks);
}
}
/// <summary>Snippet for StreamingRecognize</summary>
public async Task StreamingRecognize()
{
// Snippet: StreamingRecognize(CallSettings, BidirectionalStreamingSettings)
// Create client
SpeechClient speechClient = SpeechClient.Create();
// Initialize streaming call, retrieving the stream object
SpeechClient.StreamingRecognizeStream response = speechClient.StreamingRecognize();
// Sending requests and retrieving responses can be arbitrarily interleaved
// Exact sequence will depend on client/server behavior
// Create task to do something with responses from server
Task responseHandlerTask = Task.Run(async() =>
{
// Note that C# 8 code can use await foreach
AsyncResponseStream <StreamingRecognizeResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamingRecognizeResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
});
// Send requests to the server
bool done = false;
while (!done)
{
// Initialize a request
StreamingRecognizeRequest request = new StreamingRecognizeRequest
{
StreamingConfig = new StreamingRecognitionConfig(),
AudioContent = ByteString.Empty,
};
// Stream a request to the server
await response.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await response.WriteCompleteAsync();
// Await the response handler
// This will complete once all server responses have been processed
await responseHandlerTask;
// End snippet
}
public GoogleRecognitionEngineProvider(IMicrophoneContext microphoneContext, ISpeechHandlerChain speechHandlerChain)
{
try
{
m_client = SpeechClient.Create();
m_microphoneContext = microphoneContext;
m_bytesPerSecond = m_microphoneContext.SampleRate() *
m_microphoneContext.ChannelCount() *
m_microphoneContext.BytesPerSample();
m_speechHandlerChain = speechHandlerChain;
m_streamingRecognizeRequest = CreateStreamingRecognizeRequest();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
/// <summary>Snippet for StreamingRecognize</summary>
public async Task StreamingRecognize()
{
// Snippet: StreamingRecognize(CallSettings,BidirectionalStreamingSettings)
// Create client
SpeechClient speechClient = SpeechClient.Create();
// Initialize streaming call, retrieving the stream object
SpeechClient.StreamingRecognizeStream duplexStream = speechClient.StreamingRecognize();
// Sending requests and retrieving responses can be arbitrarily interleaved.
// Exact sequence will depend on client/server behavior.
// Create task to do something with responses from server
Task responseHandlerTask = Task.Run(async() =>
{
IAsyncEnumerator <StreamingRecognizeResponse> responseStream = duplexStream.ResponseStream;
while (await responseStream.MoveNext())
{
StreamingRecognizeResponse response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
});
// Send requests to the server
bool done = false;
while (!done)
{
// Initialize a request
StreamingRecognizeRequest request = new StreamingRecognizeRequest();
// Stream a request to the server
await duplexStream.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await duplexStream.WriteCompleteAsync();
// Await the response handler.
// This will complete once all server responses have been processed.
await responseHandlerTask;
// End snippet
}
public async Task StreamingRecognizeWAV(StreamingRecognitionConfig config, Stream audioStream)
{
var streamingSTT = _clientSTT.StreamingRecognize(GetMetadataSTT());
var requestWithConfig = new StreamingRecognizeRequest
{
StreamingConfig = config
};
await streamingSTT.RequestStream.WriteAsync(requestWithConfig); //передаем параметры аудио
Task PrintResponsesTask = Task.Run(async() => // Пишем ответ в консоль
{
while (await streamingSTT.ResponseStream.MoveNext())
{
foreach (var result in streamingSTT.ResponseStream.Current.Results)
{
foreach (var alternative in result.RecognitionResult.Alternatives)
{
System.Console.WriteLine(alternative.Transcript);
text += alternative.Transcript;
}
}
}
});
var buffer = new byte[config.Config.SampleRateHertz / 10];
int bytesRead;
// audioStream.Position = 44;
while ((bytesRead = audioStream.Read(buffer, 0, buffer.Length)) > 0)
{
await streamingSTT.RequestStream.WriteAsync(
new StreamingRecognizeRequest
{
AudioContent = Google.Protobuf
.ByteString.CopyFrom(buffer, 0, bytesRead),
});
}
await streamingSTT.RequestStream.CompleteAsync();
await PrintResponsesTask;
}
private static StreamingRecognizeRequest GetStreamingRecognizeRequest(SpeechContext speechContext)
{
var streamingRecognizeRequest = new StreamingRecognizeRequest
{
StreamingConfig = new StreamingRecognitionConfig
{
Config = new RecognitionConfig
{
Encoding =
RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 16000,
LanguageCode = "ru",
MaxAlternatives = 0,
SpeechContexts = { speechContext }
},
InterimResults = true,
}
};
return(streamingRecognizeRequest);
}
public async Task StreamingRecognize(StreamingRecognitionConfig config, Stream audioStream)
{
var streamingSTT = _clientSTT.StreamingRecognize(GetMetadataSTT());
var requestWithConfig = new StreamingRecognizeRequest
{
StreamingConfig = config
};
await streamingSTT.RequestStream.WriteAsync(requestWithConfig);
Task PrintResponsesTask = Task.Run(async() =>
{
while (await streamingSTT.ResponseStream.MoveNext())
{
foreach (var result in streamingSTT.ResponseStream.Current.Results)
{
foreach (var alternative in result.RecognitionResult.Alternatives)
{
System.Console.WriteLine(alternative.Transcript);
}
}
}
});
var buffer = new byte[2 * 1024];
int bytesRead;
while ((bytesRead = audioStream.Read(buffer, 0, buffer.Length)) > 0)
{
await streamingSTT.RequestStream.WriteAsync(
new StreamingRecognizeRequest
{
AudioContent = Google.Protobuf
.ByteString.CopyFrom(buffer, 0, bytesRead),
});
}
await streamingSTT.RequestStream.CompleteAsync();
await PrintResponsesTask;
}
private async void OnDataAvailable(object sender, WaveInEventArgs e)
{
//Debug.WriteLine(nameof(OnDataAvailable) + ": Start");
var audioRequest = new StreamingRecognizeRequest()
{
AudioContent = RecognitionAudio.FromBytes(e.Buffer, 0, e.BytesRecorded).Content
};
try
{
if (_call != null && _canWrite)
{
await _call.RequestStream.WriteAsync(audioRequest);
}
}
catch (Exception ex)
{
Debug.WriteLine(nameof(OnDataAvailable) + ": Failed send data" + ex.Message);
}
//Debug.WriteLine(nameof(OnDataAvailable) + ": End");
}
public override stt::Task WriteAsync(StreamingRecognizeRequest message, grpccore::WriteOptions options) => _writeBuffer.WriteAsync(ModifyRequest(message), options);
private StreamingRecognizeRequest ModifyRequest(StreamingRecognizeRequest request)
{
_service.Modify_StreamingRecognizeRequestRequest(ref request);
return(request);
}
public override stt::Task WriteAsync(StreamingRecognizeRequest message) => _writeBuffer.WriteAsync(ModifyRequest(message));
partial void Modify_StreamingRecognizeRequestRequest(ref StreamingRecognizeRequest request);
private async Task <int> StreamingMicRecognizeAsync()
{
try
{
_writeMore = true;
timer = new Stopwatch();
timer.Start();
if (WaveIn.DeviceCount < 1)
{
throw new ApplicationException("No microphone!");
}
_speechClient = SpeechClient.Create();
var stream = _speechClient.StreamingRecognize();
streams.Add(stream);
var speechContext = new SpeechContext();
speechContext.Phrases.AddRange(new[]
{ "int", "for", "true", "false", "public", "private", "bool", "static", "void", "переменная" }
/*.Concat(_variableProvider.GetVariables().Select(v => v.Name))*/);
// Write the initial request with the config.
StreamingRecognizeRequest recognizeRequest = GetStreamingRecognizeRequest(speechContext);
await stream.WriteAsync(recognizeRequest);
// Print responses as they arrive.
Task printResponses = Task.Run(async() =>
{
while (await stream.ResponseStream.MoveNext(default(CancellationToken)))
{
foreach (StreamingRecognitionResult streamingRecognitionResult in stream
.ResponseStream
.Current.Results)
{
if (streamingRecognitionResult.IsFinal)
{
var transcript = streamingRecognitionResult.Alternatives[0].Transcript;
OnSpeechRecognized?.Invoke(this, new SpeechRecognizerEventArgs(transcript));
if (timer.Elapsed.TotalSeconds >= threshold)
{
Restart();
}
}
}
}
});
// Read from the microphone and stream to API.
ActivateMicrophone();
Console.WriteLine("Speak now.");
//await Task.Delay(TimeSpan.FromSeconds(seconds));
// Stop recording and shut down.
//StopRecognition();
await printResponses;
//await printResponses;
return(0);
}
catch (Exception e)
{
Debug.WriteLine(e);
}
return(-1);
}
/// <inheritdoc/> public override Task TryWriteAsync(StreamingRecognizeRequest message, WriteOptions options) => _writeBuffer.TryWriteAsync(ModifyRequest(message), options);
static void Main(string[] args)
{
// 証明書を作成
var credential = GoogleCredential.FromJson(File.ReadAllText("SpeechTest-4db378c087bb.json"));
credential = credential.CreateScoped("https://www.googleapis.com/auth/cloud-platform");
// サーバに接続するためのチャンネルを作成
var channel = new Channel("speech.googleapis.com:443", credential.ToChannelCredentials());
// Google Speech APIを利用するためのクライアントを作成
var client = new Speech.SpeechClient(channel);
// ストリーミングの設定
var streamingConfig = new StreamingRecognitionConfig
{
Config = new RecognitionConfig
{
SampleRate = 16000,
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
LanguageCode = "ja-JP",
},
InterimResults = true,
SingleUtterance = false,
};
// ストリーミングを開始
using (var call = client.StreamingRecognize())
{
Console.WriteLine("-----------\nstart.\n");
// Cloud Speech APIからレスポンスが返ってきた時の挙動を設定
var responseReaderTask = Task.Run(async() =>
{
// MoveNext１回につきレスポンス１回分のデータがくる
while (await call.ResponseStream.MoveNext())
{
var note = call.ResponseStream.Current;
// データがあれば、認識結果を出力する
if (note.Results != null && note.Results.Count > 0 &&
note.Results[0].Alternatives.Count > 0)
{
Console.WriteLine("result: " + note.Results[0].Alternatives[0].Transcript);
}
}
});
// 最初の呼び出しを行う。最初は設定データだけを送る
var initialRequest = new StreamingRecognizeRequest
{
StreamingConfig = streamingConfig,
};
call.RequestStream.WriteAsync(initialRequest).Wait();
// 録音モデルの作成
IAudioRecorder recorder = new RecordModel();
// 録音モデルが音声データを吐いたら、それをすかさずサーバに送信する
recorder.RecordDataAvailabled += (sender, e) =>
{
if (e.Length > 0)
{
// WriteAsyncは一度に一回しか実行できないので非同期処理の時は特に注意
// ここではlockをかけて処理が重ならないようにしている
lock (recorder)
{
call.RequestStream.WriteAsync(new StreamingRecognizeRequest
{
AudioContent = RecognitionAudio.FromBytes(e.Buffer, 0, e.Length).Content,
}).Wait();
}
}
};
// 録音の開始
recorder.Start();
// Cloud Speech APIのストリーミングは1回60秒までなので、50秒まできたら打ち切る
var timer = new Timer(1000 * 50);
timer.Start();
// 50秒経過した時、実際に打ち切るコード
timer.Elapsed += async(sender, e) =>
{
recorder.Stop();
await call.RequestStream.CompleteAsync();
};
// 待機
responseReaderTask.Wait();
// ここに到達した時点で、APIの呼び出しが終了したということなので、タイマーを切る
timer.Dispose();
}
Console.WriteLine("\n-----------\nCompleted (Time out)");
Console.ReadKey();
}
/// <summary>
/// Asynchronously streams audio to the Google Cloud Speech server and receives results.
/// </summary>
static async Task StreamingRequest()
{
using (var call = m_Client.StreamingRecognize())
{
Task responseReaderTask = Task.Run(async() =>
{
while (await call.ResponseStream.MoveNext())
{
StreamingRecognizeResponse response = call.ResponseStream.Current;
var responseJSON = new JSONObject();
if (response.Error != null)
{
var errorJSON = new JSONObject();
errorJSON.AddField("code", response.Error.Code);
errorJSON.AddField("message", response.Error.Message);
responseJSON.AddField("error", errorJSON);
}
if (response.Results != null && response.Results.Count > 0)
{
var resultsJSON = new JSONObject();
foreach (var result in response.Results)
{
var resultJSON = new JSONObject();
if (result.Alternatives != null && result.Alternatives.Count > 0)
{
var alternativesJSON = new JSONObject();
foreach (var alternative in result.Alternatives)
{
var alternativeJSON = new JSONObject();
alternativeJSON.AddField("transcript", alternative.Transcript);
alternativeJSON.AddField("confidence", alternative.Confidence);
alternativesJSON.Add(alternativeJSON);
}
resultJSON.AddField("alternatives", alternativesJSON);
resultJSON.AddField("is_final", result.IsFinal);
resultJSON.AddField("stability", result.Stability);
}
resultsJSON.Add(resultJSON);
}
responseJSON.AddField("results", resultsJSON);
}
responseJSON.AddField("result_index", response.ResultIndex);
responseJSON.AddField("endpointer_type", response.EndpointerType.ToString());
Console.WriteLine("response: " + responseJSON);
}
});
// Send initial config request
var configRequest = new StreamingRecognizeRequest();
var streamingRecognitionConfig = new StreamingRecognitionConfig();
var recognitionConfig = new RecognitionConfig();
recognitionConfig.Encoding = RecognitionConfig.Types.AudioEncoding.LINEAR16;
recognitionConfig.SampleRate = 16000;
streamingRecognitionConfig.InterimResults = true;
streamingRecognitionConfig.SingleUtterance = false;
streamingRecognitionConfig.Config = recognitionConfig;
configRequest.StreamingConfig = streamingRecognitionConfig;
await call.RequestStream.WriteAsync(configRequest);
// Send audio chunks
Task sendChunksTask = SendChunks(call);
await sendChunksTask;
await call.RequestStream.CompleteAsync();
await responseReaderTask;
call.Dispose();
}
}
