private async Task <object> StreamingMicRecognizeAsync(int SampleRate, int timeseconds, CancellationToken ct)
{
streamingGoogle = await GetGoogleStream(SampleRate);
DateTime lastWrite = DateTime.Now;
// Print responses as they arrive.
Task receiveResponses = Task.Run(async() =>
{
var responseStream = streamingGoogle.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamingRecognizeResponse response = responseStream.Current;
foreach (StreamingRecognitionResult result in response.Results)
{
foreach (SpeechRecognitionAlternative alternative in result.Alternatives)
{
OnTextRecognized(alternative.Transcript);
lastWrite = DateTime.Now;
}
}
}
});
InitializedStreaming = true;
writeMore = true;
try { await Task.Delay(TimeSpan.FromSeconds(timeseconds), ct); }
catch { /* expected exception when cancels */ }
while (DateTime.Now - lastWrite > TimeSpan.FromSeconds(2) &&
DateTime.Now - lastWrite < TimeSpan.FromSeconds(10) &&
!ct.IsCancellationRequested)
{
await Task.Delay(100);
}
// Stop write data to speech server and buffer in memory.
lock (writeLock)
writeMore = false;
if (ct.IsCancellationRequested)
{
InitializedStreaming = false;
}
await streamingGoogle.WriteCompleteAsync();
await receiveResponses.ConfigureAwait(false);
return(0);
}
public async Task StartRecording()
{
_speechClient = SpeechClient.Create();
_streamingRecognizeStream = _speechClient.StreamingRecognize();
// Write the initial request with the config.
await _streamingRecognizeStream.WriteAsync(
new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding =
RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 16000,
LanguageCode = "ro"
},
InterimResults = false,
SingleUtterance = false
}
});
_sendResponses = Task.Run(async() =>
{
var responseStream = _streamingRecognizeStream.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamingRecognizeResponse response = responseStream.Current;
foreach (StreamingRecognitionResult result in response.Results)
{
foreach (SpeechRecognitionAlternative alternative in result.Alternatives)
{
await Clients.All.SendAsync("ReceiveMessage", alternative.Transcript);
}
}
}
});
}
public static async void StartRecordingAsync(double confidence, string language, string serviceAcc)
{
writeLock = new object();
writeMore = true;
waveIn = new WaveInEvent();
streamingCall = null;
text = default(String);
if (WaveIn.DeviceCount < 1)
{
throw new Exception("No microphone!");
}
var speech = default(SpeechClient);
try
{
GoogleCredential googleCredential;
using (Stream m = new FileStream(serviceAcc, FileMode.Open))
googleCredential = GoogleCredential.FromStream(m);
var channel = new Grpc.Core.Channel(SpeechClient.DefaultEndpoint.Host,
googleCredential.ToChannelCredentials());
speech = SpeechClient.Create(channel);
}
catch (Exception e)
{
throw e;
}
streamingCall = speech.StreamingRecognize();
// Write the initial request with the config.
try
{
await streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding =
RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 16000,
LanguageCode = language,
},
InterimResults = true,
}
});
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
// Print responses as they arrive.
Task printResponses = Task.Run(async() =>
{
while (await streamingCall.ResponseStream.MoveNext(
default(CancellationToken)))
{
foreach (var result in streamingCall.ResponseStream
.Current.Results)
{
foreach (var alternative in result.Alternatives)
{
if (alternative.Confidence > confidence)
{
text = alternative.Transcript;
Console.WriteLine(text);
}
else
{
text = String.Empty;
}
}
}
}
});
// Read from the microphone and stream to API.
waveIn.DeviceNumber = 0;
waveIn.WaveFormat = new WaveFormat(16000, 1);
waveIn.DataAvailable +=
(object sender, WaveInEventArgs args) =>
{
lock (writeLock)
{
if (!writeMore)
{
return;
}
try
{
streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
AudioContent = ByteString
.CopyFrom(args.Buffer, 0, args.BytesRecorded)
}).Wait();
}
catch (Exception e)
{
throw e.InnerException;
}
}
};
waveIn.StartRecording();
Console.WriteLine("Speak now.");
return;
}
