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);
}
/// <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
}
/// <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 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);
}
}
}
});
}
static async Task <object> StreamingMicRecognizeAsync(int seconds)
{
/* SpeechClientBuilder builder = new SpeechClientBuilder
* {
* CredentialsPath = credentialsFilePath
* };
* SpeechClient speech = builder.Build();*/
var speech = SpeechClient.Create();
var streamingCall = speech.StreamingRecognize();
// Write the initial request with the config.
await streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding =
RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 16000,
LanguageCode = "en-GB",
// The `model` value must be one of the following:
// "video", "phone_call", "command_and_search", "default"
Model = "phone_call",
// EnableWordTimeOffsets = true,
/* DiarizationConfig = new SpeakerDiarizationConfig()
* {
* EnableSpeakerDiarization = true,
* MinSpeakerCount = 2
* }*/
UseEnhanced = true,
},
InterimResults = false,
}
});
// Print responses as they arrive.
Task printResponses = Task.Run(async() =>
{
var responseStream = streamingCall.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamingRecognizeResponse response = responseStream.Current;
foreach (StreamingRecognitionResult result in response.Results)
{
foreach (SpeechRecognitionAlternative alternative in result.Alternatives)
{
Console.WriteLine(alternative.Transcript);
}
}
}
});
// Read from the microphone and stream to API.
object writeLock = new object();
bool writeMore = true;
var waveIn = new NAudio.Wave.WaveInEvent();
waveIn.DeviceNumber = 0;
waveIn.WaveFormat = new NAudio.Wave.WaveFormat(16000, 1);
waveIn.DataAvailable +=
(object sender, NAudio.Wave.WaveInEventArgs args) =>
{
lock (writeLock)
{
if (!writeMore)
{
return;
}
streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
AudioContent = Google.Protobuf.ByteString
.CopyFrom(args.Buffer, 0, args.BytesRecorded)
}).Wait();
}
};
waveIn.StartRecording();
Console.WriteLine("Speak now.");
await Task.Delay(TimeSpan.FromSeconds(seconds));
// Stop recording and shut down.
waveIn.StopRecording();
lock (writeLock)
{
writeMore = false;
}
await streamingCall.WriteCompleteAsync();
await printResponses;
return(0);
}
public static async Task <object> StreamingMicRecognizeAsync(int seconds)
{
var speech = SpeechClient.Create();
var streamingCall = speech.StreamingRecognize();
await streamingCall.WriteAsync(new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 16000,
LanguageCode = "en"
},
InterimResults = true
}
});
//Stama risposte in tempo reale
Task printResponses = Task.Run(async() =>
{
var responseStream = streamingCall.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamingRecognizeResponse response = responseStream.Current;
foreach (StreamingRecognitionResult result in response.Results)
{
foreach (SpeechRecognitionAlternative alternative in result.Alternatives)
{
Debug.WriteLine(alternative.Transcript);
}
}
}
});
//Lettura dal microfono e stream alle API di Google
object writeLock = new object();
bool writeMore = true;
var waveIn = new NAudio.Wave.WaveInEvent();
waveIn.DeviceNumber = 0;
waveIn.WaveFormat = new NAudio.Wave.WaveFormat(16000, 1);
waveIn.DataAvailable += (object sender, NAudio.Wave.WaveInEventArgs args) =>
{
lock (writeLock)
{
if (!writeMore)
{
return;
}
streamingCall.WriteAsync(new StreamingRecognizeRequest()
{
AudioContent = Google.Protobuf.ByteString.CopyFrom(args.Buffer, 0, args.BytesRecorded)
}).Wait();
}
};
waveIn.StartRecording();
Debug.WriteLine("Parla ora!");
await Task.Delay(TimeSpan.FromSeconds(seconds)); //il task è programmato per finire dopo seconds secondi
//stop recording and shut down
waveIn.StopRecording();
lock (writeLock)
{
writeMore = false;
}
await streamingCall.WriteCompleteAsync();
await printResponses;
return(0);
}
// [END speech_transcribe_streaming]
// [START speech_transcribe_streaming_mic]
static async Task <object> StreamingMicRecognizeAsync(int seconds)
{
var speech = SpeechClient.Create();
var streamingCall = speech.StreamingRecognize();
// Write the initial request with the config.
await streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding =
RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 16000,
LanguageCode = "en",
},
InterimResults = true,
}
});
// Print responses as they arrive.
Task printResponses = Task.Run(async() =>
{
var responseStream = streamingCall.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamingRecognizeResponse response = responseStream.Current;
foreach (StreamingRecognitionResult result in response.Results)
{
foreach (SpeechRecognitionAlternative alternative in result.Alternatives)
{
Console.WriteLine(alternative.Transcript);
}
}
}
});
// Read from the microphone and stream to API.
object writeLock = new object();
bool writeMore = true;
var waveIn = new NAudio.Wave.WaveInEvent();
waveIn.DeviceNumber = 0;
waveIn.WaveFormat = new NAudio.Wave.WaveFormat(16000, 1);
waveIn.DataAvailable +=
(object sender, NAudio.Wave.WaveInEventArgs args) =>
{
lock (writeLock)
{
if (!writeMore)
{
return;
}
streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
AudioContent = Google.Protobuf.ByteString
.CopyFrom(args.Buffer, 0, args.BytesRecorded)
}).Wait();
}
};
waveIn.StartRecording();
Console.WriteLine("Speak now.");
await Task.Delay(TimeSpan.FromSeconds(seconds));
// Stop recording and shut down.
waveIn.StopRecording();
lock (writeLock)
{
writeMore = false;
}
await streamingCall.WriteCompleteAsync();
await printResponses;
return(0);
}
// [END speech_transcribe_async_word_time_offsets_gcs]
/// <summary>
/// Stream the content of the file to the API in 32kb chunks.
/// </summary>
// [START speech_transcribe_streaming]
static async Task <object> StreamingRecognizeAsync(string filePath)
{
var speech = SpeechClient.Create();
var streamingCall = speech.StreamingRecognize();
// Write the initial request with the config.
await streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding =
RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 16000,
LanguageCode = "en",
},
InterimResults = true,
}
});
// Print responses as they arrive.
Task printResponses = Task.Run(async() =>
{
var responseStream = streamingCall.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamingRecognizeResponse response = responseStream.Current;
foreach (StreamingRecognitionResult result in response.Results)
{
foreach (SpeechRecognitionAlternative alternative in result.Alternatives)
{
Console.WriteLine(alternative.Transcript);
}
}
}
});
// Stream the file content to the API. Write 2 32kb chunks per
// second.
using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
{
var buffer = new byte[32 * 1024];
int bytesRead;
while ((bytesRead = await fileStream.ReadAsync(
buffer, 0, buffer.Length)) > 0)
{
await streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
AudioContent = Google.Protobuf.ByteString
.CopyFrom(buffer, 0, bytesRead),
});
await Task.Delay(500);
}
;
}
await streamingCall.WriteCompleteAsync();
await printResponses;
return(0);
}
/// <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();
}
}
static async Task <object> StreamingMicrophoneRecognizeAsync(int seconds = 60, string languageCode = "en-US")
{
var speech = SpeechClient.Create();
var streamingCall = speech.StreamingRecognize();
await streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 44100,
LanguageCode = languageCode
},
InterimResults = true,
}
});
Task printResponses = Task.Run(async() =>
{
var responseStream = streamingCall.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamingRecognizeResponse response = responseStream.Current;
Console.WriteLine(response.Results[0].Alternatives[0].Transcript); // Print most probable result.
}
});
object writeLock = new object();
bool writeMore = true;
var waveIn = new NAudio.Wave.WaveInEvent();
waveIn.DeviceNumber = 0;
waveIn.WaveFormat = new NAudio.Wave.WaveFormat(44100, 1); // 44100Hz Mono.
waveIn.DataAvailable += (object sender, NAudio.Wave.WaveInEventArgs args) =>
{
lock (writeLock)
{
if (!writeMore)
{
return;
}
streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
AudioContent = Google.Protobuf.ByteString.CopyFrom(args.Buffer, 0, args.BytesRecorded)
}).Wait();
}
};
waveIn.StartRecording();
Console.WriteLine("Speek now.");
await Task.Delay(TimeSpan.FromSeconds(seconds));
waveIn.StopRecording();
lock (writeLock)
{
writeMore = false;
}
await streamingCall.WriteCompleteAsync();
await printResponses;
return(0);
}
