private async Task StartStreamAsync()
{
var now = DateTime.UtcNow;
if (m_rpcStream != null && now >= m_rpcStreamDeadline)
{
Console.WriteLine($"Closing stream before it times out");
await m_rpcStream.WriteCompleteAsync();
m_rpcStream.GrpcCall.Dispose();
m_rpcStream = null;
}
// If we have a valid stream at this point, we're fine.
if (m_rpcStream != null)
{
return;
}
// We need to create a new stream, either because we're just starting or because we've just closed the previous one.
m_rpcStream = m_client.StreamingRecognize();
m_rpcStreamDeadline = now + s_streamTimeLimit;
m_processingBufferStart = TimeSpan.Zero;
m_serverResponseAvailableTask = m_rpcStream.GetResponseStream().MoveNextAsync();
await m_rpcStream.WriteAsync(m_streamingRecognizeRequest);
Console.WriteLine($"Writing {m_speechUnprocessedBuffer.Count} chunks into the new stream.");
foreach (var chunk in m_speechUnprocessedBuffer)
{
await WriteAudioChunk(chunk);
}
}
public async Task Close()
{
lock (_writeLock)
{
IsOpen = false;
//_closeTokenSource?.Cancel();
}
_audioFileStream.Close();
await _streamingCall.WriteCompleteAsync();
await _handleResponses;
}
/// <summary>
/// Starts a new RPC streaming call if necessary. This will be if either it's the first call
/// (so we don't have a current request) or if the current request will time out soon.
/// In the latter case, after starting the new request, we copy any chunks we'd already sent
/// in the previous request which hadn't been included in a "final result".
/// </summary>
private async Task MaybeStartStreamAsync()
{
var now = DateTime.UtcNow;
if (_rpcStream != null && now >= _rpcStreamDeadline)
{
Console.WriteLine($"Closing stream before it times out");
await _rpcStream.WriteCompleteAsync();
_rpcStream.GrpcCall.Dispose();
_rpcStream = null;
}
// If we have a valid stream at this point, we're fine.
if (_rpcStream != null)
{
//Console.WriteLine("We already have a google stream");
return;
}
var translationLanguage = MapLanguageCodeToGoogleLanguage(_myct.FromLang);
Console.WriteLine($"Creating new google stream to translate from {translationLanguage}");
// We need to create a new stream, either because we're just starting or because we've just closed the previous one.
_rpcStream = _client.StreamingRecognize();
_rpcStreamDeadline = now + s_streamTimeLimit;
_processingBufferStart = TimeSpan.Zero;
_serverResponseAvailableTask = _rpcStream.GetResponseStream().MoveNextAsync();
await _rpcStream.WriteAsync(new StreamingRecognizeRequest
{
StreamingConfig = new StreamingRecognitionConfig
{
Config = new RecognitionConfig
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = SampleRate,
LanguageCode = translationLanguage,// _myct.FromLang,//"en-US",
MaxAlternatives = 1,
UseEnhanced = true,
EnableAutomaticPunctuation = true
},
InterimResults = true,
//SingleUtterance=false
}
});
Console.WriteLine($"Writing {_processingBuffer.Count} chunks into the new stream.");
foreach (var chunk in _processingBuffer)
{
await WriteAudioChunk(chunk);
}
}
/// <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 async void End()
{
timer.Change(Timeout.Infinite, Timeout.Infinite);
stream.Close();
IsReady = false;
systemLog.DebugFormat("{0} Google Speech To Text stream ended", prefix);
await streaming.WriteCompleteAsync();
await handle;
Task.Run(() => engine.RecognizeAsyncCancel());
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public async Task BeginSpeechRecognition()
{
if (null == waveIn)
{
return;
}
waveIn.StartRecording();
await Task.Run(() =>
{
var startTicks = DateTime.Now;
do
{
var currentTime = DateTime.Now;
TimeSpan interval = currentTime - startTicks;
if (interval.TotalSeconds >= 55)
{
lock (writeLock)
{
streamingCall.WriteCompleteAsync();
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
ConfigureSpeechRequest(RecognitionConfig.Types.AudioEncoding.Linear16, 16000, "en", false);
ProcessResponses();
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
}
startTicks = DateTime.Now;
}
}while (true);
}
);
return;
}
public async Task StopRecording()
{
if (_mediaCapture == null)
{
return;
}
await _mediaCapture.StopRecordAsync();
await _streamingCall.WriteCompleteAsync();
_mediaCapture = null;
_isRecording = false;
}
/// <summary>
/// Starts a new RPC streaming call if necessary. This will be if either it's the first call
/// (so we don't have a current request) or if the current request will time out soon.
/// In the latter case, after starting the new request, we copy any chunks we'd already sent
/// in the previous request which hadn't been included in a "final result".
/// </summary>
private async Task MaybeStartStreamAsync()
{
var now = DateTime.UtcNow;
if (_rpcStream != null && now >= _rpcStreamDeadline)
{
Console.WriteLine($"Closing stream before it times out");
await _rpcStream.WriteCompleteAsync();
_rpcStream.GrpcCall.Dispose();
_rpcStream = null;
}
// If we have a valid stream at this point, we're fine.
if (_rpcStream != null)
{
return;
}
// We need to create a new stream, either because we're just starting or because we've just closed the previous one.
_rpcStream = _client.StreamingRecognize();
_rpcStreamDeadline = now + s_streamTimeLimit;
_processingBufferStart = TimeSpan.Zero;
_serverResponseAvailableTask = _rpcStream.GetResponseStream().MoveNextAsync();
await _rpcStream.WriteAsync(new StreamingRecognizeRequest
{
StreamingConfig = new StreamingRecognitionConfig
{
Config = new RecognitionConfig
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = SampleRate,
LanguageCode = "en-US",
MaxAlternatives = 1
},
InterimResults = true,
}
});
Console.WriteLine($"Writing {_processingBuffer.Count} chunks into the new stream.");
foreach (var chunk in _processingBuffer)
{
await WriteAudioChunk(chunk);
}
}
/// <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 <string> Stop()
{
Task <string> printResponses = Task.Run(async() =>
{
string res = "";
while (await StreamingCall.ResponseStream.MoveNext(
default(CancellationToken)))
{
res = StreamingCall.ResponseStream.Current.Results.Last().Alternatives.Last().Transcript;
}
return(res);
});
WaveIn.StopRecording();
lock (WriteLock) WriteMore = false;
await StreamingCall.WriteCompleteAsync();
var textResult = await printResponses;
return(textResult);
}
private static async Task <object> StreamingMicRecognizeAsync(int seconds)
{
if (WaveIn.DeviceCount < 1)
{
File.WriteAllText("error.txt", "No microphone!");
return((object)-1);
}
string lower = INISetting.GetValueWithAdd <string>("CredentialsFilePath", "credentials.json").ToLower();
Console.WriteLine(lower);
GoogleCredential googleCredential;
using (Stream stream = (Stream) new FileStream(lower, FileMode.Open))
googleCredential = GoogleCredential.FromStream(stream);
SpeechClient.StreamingRecognizeStream streamingCall = SpeechClient.Create(new Channel(SpeechClient.DefaultEndpoint.Host, googleCredential.ToChannelCredentials())).StreamingRecognize();
await streamingCall.WriteAsync(new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 16000,
LanguageCode = "ru"
},
InterimResults = true
}
});
Task printResponses = Task.Run((Func <Task>)(async() =>
{
string s = "";
while (true)
{
if (await streamingCall.ResponseStream.MoveNext(new CancellationToken()))
{
using (IEnumerator <StreamingRecognitionResult> enumerator1 = streamingCall.ResponseStream.Current.Results.GetEnumerator())
{
if (enumerator1.MoveNext())
{
using (IEnumerator <SpeechRecognitionAlternative> enumerator2 = enumerator1.Current.Alternatives.GetEnumerator())
{
if (enumerator2.MoveNext())
{
SpeechRecognitionAlternative current = enumerator2.Current;
Console.WriteLine(current.Transcript);
s += current.Transcript;
}
}
}
}
File.WriteAllText(Path.GetTempPath() + "\\speechtext\\speechtext.txt", s);
s = "";
}
else
{
break;
}
}
}));
object writeLock = new object();
bool writeMore = true;
WaveInEvent waveIn = new WaveInEvent();
waveIn.DeviceNumber = 0;
waveIn.WaveFormat = new WaveFormat(16000, 1);
waveIn.DataAvailable += (EventHandler <WaveInEventArgs>)((sender, args) =>
{
lock (writeLock)
{
if (!writeMore)
{
return;
}
streamingCall.WriteAsync(new StreamingRecognizeRequest()
{
AudioContent = ByteString.CopyFrom(args.Buffer, 0, args.BytesRecorded)
}).Wait();
}
});
waveIn.StartRecording();
Console.WriteLine("Speak now " + (object)seconds);
await Task.Delay(TimeSpan.FromSeconds((double)seconds));
waveIn.StopRecording();
lock (writeLock)
writeMore = false;
await streamingCall.WriteCompleteAsync();
await printResponses;
return((object)0);
}
