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); }