/// <summary>
/// Performs synchronous speech recognition: receive results after all audio
/// has been sent and processed.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// The RPC response.
/// </returns>
public override RecognizeResponse Recognize(
RecognizeRequest request,
gaxgrpc::CallSettings callSettings = null)
{
Modify_RecognizeRequest(ref request, ref callSettings);
return(_callRecognize.Sync(request, callSettings));
}
public string Recognize(RecognitionConfig config, Stream audioStream)
{
byte[] audioBytes;
using (MemoryStream buffer = new MemoryStream())
{
audioStream.CopyTo(buffer);
audioBytes = buffer.ToArray();
}
RecognizeRequest request = new RecognizeRequest();
request.Config = config;
request.Audio = new RecognitionAudio
{
Content = Google.Protobuf.ByteString.CopyFrom(audioBytes, 0, audioBytes.Length)
};
var response = _clientSTT.Recognize(request, this.GetMetadataSTT());
var texts = new List <string>();
foreach (var result in response.Results)
{
foreach (var alt in result.Alternatives)
{
texts.Add(alt.Transcript);
}
}
return(string.Join(" ", texts));
}
public async stt::Task RecognizeRequestObjectAsync()
{
moq::Mock <Speech.SpeechClient> mockGrpcClient = new moq::Mock <Speech.SpeechClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig(),
Audio = new RecognitionAudio(),
};
RecognizeResponse expectedResponse = new RecognizeResponse
{
Results =
{
new SpeechRecognitionResult(),
},
TotalBilledTime = new wkt::Duration(),
};
mockGrpcClient.Setup(x => x.RecognizeAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <RecognizeResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
SpeechClient client = new SpeechClientImpl(mockGrpcClient.Object, null);
RecognizeResponse responseCallSettings = await client.RecognizeAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
RecognizeResponse responseCancellationToken = await client.RecognizeAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
private void OnRecognizeResponse(RESTConnector.Request req, RESTConnector.Response resp)
{
RecognizeRequest recognizeReq = req as RecognizeRequest;
if (recognizeReq == null)
{
throw new WatsonException("Unexpected request type.");
}
SpeechResultList result = null;
if (resp.Success)
{
result = ParseRecognizeResponse(resp.Data);
if (result == null)
{
Log.Error("SpeechToText", "Failed to parse json response: {0}",
resp.Data != null ? Encoding.UTF8.GetString(resp.Data) : "");
}
else
{
Log.Status("SpeechToText", "Received Recognize Response, Elapsed Time: {0}, Results: {1}",
resp.ElapsedTime, result.Results.Length);
}
}
else
{
Log.Error("SpeechToText", "Recognize Error: {0}", resp.Error);
}
if (recognizeReq.Callback != null)
{
recognizeReq.Callback(result);
}
}
/// <summary>Snippet for RecognizeAsync</summary>
public async Task RecognizeAsync_RequestObject()
{
// Snippet: RecognizeAsync(RecognizeRequest,CallSettings)
// Additional: RecognizeAsync(RecognizeRequest,CancellationToken)
// Create client
SpeechClient speechClient = await SpeechClient.CreateAsync();
// Initialize request argument(s)
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig
{
Encoding = RecognitionConfig.Types.AudioEncoding.Flac,
SampleRateHertz = 44100,
LanguageCode = "en-US",
},
Audio = new RecognitionAudio
{
Uri = "gs://bucket_name/file_name.flac",
},
};
// Make the request
RecognizeResponse response = await speechClient.RecognizeAsync(request);
// End snippet
}
/// <summary>
/// Adds additional details short audio file included in this recognition request
/// </summary>
/// <param name="localFilePath">Path to local audio file, e.g. /path/audio.wav</param>
public static void SampleRecognize(string localFilePath)
{
SpeechClient speechClient = SpeechClient.Create();
// string localFilePath = "resources/commercial_mono.wav"
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig
{
Metadata = new RecognitionMetadata
{
InteractionType = RecognitionMetadata.Types.InteractionType.VoiceSearch,
RecordingDeviceType = RecognitionMetadata.Types.RecordingDeviceType.Smartphone,
RecordingDeviceName = "Pixel 3",
},
// The language of the supplied audio. Even though additional languages are
// provided by alternative_language_codes, a primary language is still required.
LanguageCode = "en-US",
},
Audio = new RecognitionAudio
{
Content = ByteString.CopyFrom(File.ReadAllBytes(localFilePath)),
},
};
RecognizeResponse response = speechClient.Recognize(request);
foreach (var result in response.Results)
{
// First alternative is the most probable result
SpeechRecognitionAlternative alternative = result.Alternatives[0];
Console.WriteLine($"Transcript: {alternative.Transcript}");
}
}
/// <summary>
/// Print confidence level for individual words in a transcription of a short audio file
/// </summary>
/// <param name="localFilePath">Path to local audio file, e.g. /path/audio.wav</param>
public static void SampleRecognize(string localFilePath)
{
SpeechClient speechClient = SpeechClient.Create();
// string localFilePath = "resources/brooklyn_bridge.flac"
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig
{
// When enabled, the first result returned by the API will include a list
// of words and the confidence level for each of those words.
EnableWordConfidence = true,
// The language of the supplied audio
LanguageCode = "en-US",
},
Audio = new RecognitionAudio
{
Content = ByteString.CopyFrom(File.ReadAllBytes(localFilePath)),
},
};
RecognizeResponse response = speechClient.Recognize(request);
// The first result includes confidence levels per word
SpeechRecognitionResult result = response.Results[0];
// First alternative is the most probable result
SpeechRecognitionAlternative alternative = result.Alternatives[0];
Console.WriteLine($"Transcript: {alternative.Transcript}");
// Print the confidence level of each word
foreach (var word in alternative.Words)
{
Console.WriteLine($"Word: {word.Word}");
Console.WriteLine($"Confidence: {word.Confidence}");
}
}
/// <summary>
/// Transcribe a short audio file with language detected from a list of possible languages
/// </summary>
/// <param name="localFilePath">Path to local audio file, e.g. /path/audio.wav</param>
public static void SampleRecognize(string localFilePath)
{
SpeechClient speechClient = SpeechClient.Create();
// string localFilePath = "resources/brooklyn_bridge.flac"
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig
{
// The language of the supplied audio. Even though additional languages are
// provided by alternative_language_codes, a primary language is still required.
LanguageCode = "fr",
AlternativeLanguageCodes =
{
"es",
"en",
},
},
Audio = new RecognitionAudio
{
Content = ByteString.CopyFrom(File.ReadAllBytes(localFilePath)),
},
};
RecognizeResponse response = speechClient.Recognize(request);
foreach (var result in response.Results)
{
// The languageCode which was detected as the most likely being spoken in the audio
Console.WriteLine($"Detected language: {result.LanguageCode}");
// First alternative is the most probable result
SpeechRecognitionAlternative alternative = result.Alternatives[0];
Console.WriteLine($"Transcript: {alternative.Transcript}");
}
}
/// <summary>
/// Transcribe a short audio file with punctuation
/// </summary>
/// <param name="localFilePath">Path to local audio file, e.g. /path/audio.wav</param>
public static void SampleRecognize(string localFilePath)
{
SpeechClient speechClient = SpeechClient.Create();
// string localFilePath = "resources/commercial_mono.wav"
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig
{
// When enabled, trascription results may include punctuation (available for select languages).
EnableAutomaticPunctuation = true,
// The language of the supplied audio. Even though additional languages are
// provided by alternative_language_codes, a primary language is still required.
LanguageCode = "en-US",
},
Audio = new RecognitionAudio
{
Content = ByteString.CopyFrom(File.ReadAllBytes(localFilePath)),
},
};
RecognizeResponse response = speechClient.Recognize(request);
foreach (var result in response.Results)
{
// First alternative is the most probable result
SpeechRecognitionAlternative alternative = result.Alternatives[0];
Console.WriteLine($"Transcript: {alternative.Transcript}");
}
}
public void Recognize()
{
moq::Mock <Speech.SpeechClient> mockGrpcClient = new moq::Mock <Speech.SpeechClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig(),
Audio = new RecognitionAudio(),
};
RecognizeResponse expectedResponse = new RecognizeResponse
{
Results =
{
new SpeechRecognitionResult(),
},
TotalBilledTime = new wkt::Duration(),
};
mockGrpcClient.Setup(x => x.Recognize(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
SpeechClient client = new SpeechClientImpl(mockGrpcClient.Object, null);
RecognizeResponse response = client.Recognize(request.Config, request.Audio);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Performs synchronous speech recognition on an audio file.
/// </summary>
/// <param name="sampleRateHertz">Sample rate in Hertz of the audio data sent in all `RecognitionAudio`
/// messages. Valid values are: 8000-48000.</param>
/// <param name="languageCode">The language of the supplied audio.</param>
/// <param name="uriPath">Path to the audio file stored on GCS.</param>
public static void SampleRecognize(int sampleRateHertz, string languageCode, string uriPath)
{
SpeechClient speechClient = SpeechClient.Create();
// int sampleRateHertz = 44100
// string languageCode = "en-US"
// string uriPath = "gs://cloud-samples-data/speech/brooklyn_bridge.mp3"
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig
{
Encoding = RecognitionConfig.Types.AudioEncoding.Mp3,
// Sample rate in Hertz of the audio data sent in all `RecognitionAudio` messages. Valid values are:
// 8000-48000.
SampleRateHertz = 44100,
// The language of the supplied audio.
LanguageCode = "en-US",
},
Audio = new RecognitionAudio
{
// Path to the audio file stored on GCS.
Uri = "gs://cloud-samples-data/speech/brooklyn_bridge.mp3",
},
};
RecognizeResponse response = speechClient.Recognize(request);
foreach (var result in response.Results)
{
string transcript = result.Alternatives[0].Transcript;
Console.WriteLine($"Transcript: {transcript}");
}
}
/// <summary>
/// Performs synchronous speech recognition: receive results after all audio
/// has been sent and processed.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override stt::Task <RecognizeResponse> RecognizeAsync(
RecognizeRequest request,
gaxgrpc::CallSettings callSettings = null)
{
Modify_RecognizeRequest(ref request, ref callSettings);
return(_callRecognize.Async(request, callSettings));
}
public async Task RecognizeAsync2()
{
Mock <Speech.SpeechClient> mockGrpcClient = new Mock <Speech.SpeechClient>(MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient())
.Returns(new Mock <Operations.OperationsClient>().Object);
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig
{
Encoding = RecognitionConfig.Types.AudioEncoding.Flac,
SampleRateHertz = 44100,
LanguageCode = "en-US",
},
Audio = new RecognitionAudio
{
Uri = "gs://bucket_name/file_name.flac",
},
};
RecognizeResponse expectedResponse = new RecognizeResponse();
mockGrpcClient.Setup(x => x.RecognizeAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <RecognizeResponse>(Task.FromResult(expectedResponse), null, null, null, null));
SpeechClient client = new SpeechClientImpl(mockGrpcClient.Object, null);
RecognizeResponse response = await client.RecognizeAsync(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public IActionResult Post([FromBody] RecognizeRequest request)
{
using (var connection = _rabbitConnection.CreateConnection())
using (var channel = connection.CreateModel())
{
CreateQueue(channel);
var body = Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(request));
channel.BasicPublish(exchange: "e.recognize",
routingKey: "",
basicProperties: null,
body: body);
}
return(Ok());
}
/// <summary>Snippet for Recognize</summary>
public void Recognize_RequestObject()
{
// Snippet: Recognize(RecognizeRequest, CallSettings)
// Create client
SpeechClient speechClient = SpeechClient.Create();
// Initialize request argument(s)
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig(),
Audio = new RecognitionAudio(),
};
// Make the request
RecognizeResponse response = speechClient.Recognize(request);
// End snippet
}
/// <summary>
/// Performs synchronous speech recognition with speech adaptation.
/// </summary>
/// <param name="sampleRateHertz">Sample rate in Hertz of the audio data sent in all `RecognitionAudio`
/// messages. Valid values are: 8000-48000.</param>
/// <param name="languageCode">The language of the supplied audio.</param>
/// <param name="phrase">Phrase "hints" help Speech-to-Text API recognize the specified phrases from
/// your audio data.</param>
/// <param name="boost">Positive value will increase the probability that a specific phrase will be
/// recognized over other similar sounding phrases.</param>
/// <param name="uriPath">Path to the audio file stored on GCS.</param>
public static void SampleRecognize(int sampleRateHertz, string languageCode, string phrase, float boost, string uriPath)
{
SpeechClient speechClient = SpeechClient.Create();
// int sampleRateHertz = 44100
// string languageCode = "en-US"
// string phrase = "Brooklyn Bridge"
// float boost = 20f
// string uriPath = "gs://cloud-samples-data/speech/brooklyn_bridge.mp3"
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig
{
Encoding = RecognitionConfig.Types.AudioEncoding.Mp3,
// Sample rate in Hertz of the audio data sent in all `RecognitionAudio` messages. Valid values are:
// 8000-48000.
SampleRateHertz = 44100,
// The language of the supplied audio.
LanguageCode = "en-US",
SpeechContexts =
{
new SpeechContext
{
Phrases =
{
"Brooklyn Bridge",
},
// Positive value will increase the probability that a specific phrase will be recognized over other
// similar sounding phrases.
Boost = 20f,
},
},
},
Audio = new RecognitionAudio
{
// Path to the audio file stored on GCS.
Uri = "gs://cloud-samples-data/speech/brooklyn_bridge.mp3",
},
};
RecognizeResponse response = speechClient.Recognize(request);
foreach (var result in response.Results)
{
// First alternative is the most probable result
SpeechRecognitionAlternative alternative = result.Alternatives[0];
Console.WriteLine($"Transcript: {alternative.Transcript}");
}
}
/// <summary>
/// Provides "hints" to the speech recognizer to favor specific classes of words in the results.
///</summary>
/// <param name="uriPath">Path to the audio file stored on GCS.</param>
public static object TranscribeContextClasses(
string uriPath = "gs://cloud-samples-data/speech/brooklyn_bridge.mp3")
{
var speechClient = SpeechClient.Create();
SpeechContext speechContext = new SpeechContext();
// SpeechContext: to configure your speech_context see:
// https://cloud.google.com/speech-to-text/docs/reference/rpc/google.cloud.speech.v1#speechcontext
// Full list of supported phrases (class tokens) here:
// https://cloud.google.com/speech-to-text/docs/class-tokens
speechContext.Phrases.Add("$TIME");
// RecognitionConfig: to configure your encoding and sample_rate_hertz, see:
// https://cloud.google.com/speech-to-text/docs/reference/rpc/google.cloud.speech.v1#recognitionconfig
RecognitionConfig recognitionConfig = new RecognitionConfig
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = 8000,
LanguageCode = "en-US"
};
recognitionConfig.SpeechContexts.Add(speechContext);
// Set the path to your audio file
RecognitionAudio audio = new RecognitionAudio
{
Uri = uriPath
};
// Build the request
RecognizeRequest request = new RecognizeRequest
{
Config = recognitionConfig,
Audio = audio
};
// Perform the request
var response = speechClient.Recognize(request);
foreach (SpeechRecognitionResult result in response.Results)
{
// First alternative is the most probable result
var alternative = result.Alternatives[0];
Console.WriteLine($"Transcript: {alternative.Transcript}");
}
return(0);
}
/// <summary>Snippet for RecognizeAsync</summary>
public async Task RecognizeAsync_RequestObject()
{
// Snippet: RecognizeAsync(RecognizeRequest, CallSettings)
// Additional: RecognizeAsync(RecognizeRequest, CancellationToken)
// Create client
SpeechClient speechClient = await SpeechClient.CreateAsync();
// Initialize request argument(s)
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig(),
Audio = new RecognitionAudio(),
};
// Make the request
RecognizeResponse response = await speechClient.RecognizeAsync(request);
// End snippet
}
/// <summary>
/// Performs synchronous speech recognition with static context classes.
/// </summary>
/// <param name="sampleRateHertz">Sample rate in Hertz of the audio data sent in all `RecognitionAudio`
/// messages. Valid values are: 8000-48000.</param>
/// <param name="languageCode">The language of the supplied audio.</param>
/// <param name="phrase">Phrase "hints" help Speech-to-Text API recognize the specified phrases from
/// your audio data. In this sample we are using a static class phrase ($TIME). Classes represent
/// groups of words that represent common concepts that occur in natural language. We recommend
/// checking out the docs page for more info on static classes.</param>
/// <param name="uriPath">Path to the audio file stored on GCS.</param>
public static void SampleRecognize(int sampleRateHertz, string languageCode, string phrase, string uriPath)
{
SpeechClient speechClient = SpeechClient.Create();
// int sampleRateHertz = 24000
// string languageCode = "en-US"
// string phrase = "$TIME"
// string uriPath = "gs://cloud-samples-data/speech/time.mp3"
RecognizeRequest request = new RecognizeRequest
{
Config = new RecognitionConfig
{
Encoding = RecognitionConfig.Types.AudioEncoding.Mp3,
// Sample rate in Hertz of the audio data sent in all `RecognitionAudio` messages. Valid values are:
// 8000-48000.
SampleRateHertz = 24000,
// The language of the supplied audio.
LanguageCode = "en-US",
SpeechContexts =
{
new SpeechContext
{
Phrases =
{
"$TIME",
},
},
},
},
Audio = new RecognitionAudio
{
// Path to the audio file stored on GCS.
Uri = "gs://cloud-samples-data/speech/time.mp3",
},
};
RecognizeResponse response = speechClient.Recognize(request);
foreach (var result in response.Results)
{
// First alternative is the most probable result
SpeechRecognitionAlternative alternative = result.Alternatives[0];
Console.WriteLine($"Transcript: {alternative.Transcript}");
}
}
/// <summary>
/// This function POSTs the given audio clip the recognize function and convert speech into text. This function should be used
/// only on AudioClips under 4MB once they have been converted into WAV format. Use the StartListening() for continuous
/// recognition of text.
/// </summary>
/// <param name="clip">The AudioClip object.</param>
/// <param name="callback">A callback to invoke with the results.</param>
/// <returns></returns>
public bool Recognize(AudioClip clip, OnRecognize callback)
{
if (clip == null)
{
throw new ArgumentNullException("clip");
}
if (callback == null)
{
throw new ArgumentNullException("callback");
}
RESTConnector connector = RESTConnector.GetConnector(SERVICE_ID, "/v1/recognize");
if (connector == null)
{
return(false);
}
RecognizeRequest req = new RecognizeRequest();
req.Clip = clip;
req.Callback = callback;
req.Headers["Content-Type"] = "audio/wav";
req.Send = WaveFile.CreateWAV(clip);
if (req.Send.Length > MAX_RECOGNIZE_CLIP_SIZE)
{
Log.Error("SpeechToText", "AudioClip is too large for Recognize().");
return(false);
}
req.Parameters["model"] = m_RecognizeModel;
req.Parameters["continuous"] = "false";
req.Parameters["max_alternatives"] = m_MaxAlternatives.ToString();
req.Parameters["timestamps"] = m_Timestamps ? "true" : "false";
req.Parameters["word_confidence"] = m_WordConfidence ? "true" : "false";
req.OnResponse = OnRecognizeResponse;
return(connector.Send(req));
}
public void Recognize()
{
Mock <Speech.SpeechClient> mockGrpcClient = new Mock <Speech.SpeechClient>(MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient())
.Returns(new Mock <Operations.OperationsClient>().Object);
RecognizeRequest expectedRequest = new RecognizeRequest
{
Config = new RecognitionConfig
{
Encoding = RecognitionConfig.Types.AudioEncoding.Flac,
SampleRateHertz = 44100,
LanguageCode = "en-US",
},
Audio = new RecognitionAudio
{
Uri = "gs://bucket_name/file_name.flac",
},
};
RecognizeResponse expectedResponse = new RecognizeResponse();
mockGrpcClient.Setup(x => x.Recognize(expectedRequest, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
SpeechClient client = new SpeechClientImpl(mockGrpcClient.Object, null);
RecognitionConfig config = new RecognitionConfig
{
Encoding = RecognitionConfig.Types.AudioEncoding.Flac,
SampleRateHertz = 44100,
LanguageCode = "en-US",
};
RecognitionAudio audio = new RecognitionAudio
{
Uri = "gs://bucket_name/file_name.flac",
};
RecognizeResponse response = client.Recognize(config, audio);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Performs synchronous speech recognition: receive results after all audiohas been sent and processed.
/// Documentation https://developers.google.com/speech/v1/reference/speech/recognize
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Speech service.</param>
/// <param name="body">A valid Speech v1 body.</param>
/// <returns>RecognizeResponseResponse</returns>
public static RecognizeResponse Recognize(SpeechService service, RecognizeRequest body)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (body == null)
{
throw new ArgumentNullException("body");
}
// Make the request.
return(service.Speech.Recognize(body).Execute());
}
catch (Exception ex)
{
throw new Exception("Request Speech.Recognize failed.", ex);
}
}
private void Recognize()
{
SpeechClientBuilder builder = new SpeechClientBuilder();
builder.CredentialsPath = GOOGLE_API_CREDS_PATH;
SpeechClient client = builder.Build();
RecognizeRequest request = new RecognizeRequest()
{
Audio = RecognitionAudio.FromFile(TEMP_AUDIO_PATH),
Config = new RecognitionConfig()
{
Encoding = RecognitionConfig.Types.AudioEncoding.EncodingUnspecified,
LanguageCode = "ru-RU",
EnableWordTimeOffsets = false
}
};
RecognizeResponse response = client.Recognize(request);
Result.Text = string.Join("\n", response.Results.Select(
result => result.Alternatives[0].Transcript
));
}
private static async Task RecognizeRequest(
SpeechRecognition.SpeechRecognitionClient client, string model, string client_id, string domain_id, string api_key)
{
using var call = client.RecognizeSpeech();
var responseTask = Task.Run(async() => {
await foreach (var result in call.ResponseStream.ReadAllAsync())
{
var words = from w in result.Text.Words select w.Text;
Console.ForegroundColor = result.IsFinal ? ConsoleColor.DarkGreen : ConsoleColor.Gray;
Console.WriteLine(string.Join(" ", words));
Console.ResetColor();
}
});
var recorder = new WaveInEvent();
recorder.WaveFormat = new WaveFormat(16000, 1);
recorder.BufferMilliseconds = 200;
try
{
var config = new RecognizeRequest
{
Config = new RecognitionConfig
{
Model = new Model {
Id = model
},
Auth = new Auth {
ClientId = client_id, DomainId = domain_id, ApiKey = api_key
}
}
};
await call.RequestStream.WriteAsync(config);
recorder.DataAvailable += async(object sender, WaveInEventArgs e) =>
{
await call.RequestStream.WriteAsync(new RecognizeRequest
{
Sound = new Sound {
Samples = Google.Protobuf.ByteString.CopyFrom(e.Buffer)
}
});
};
recorder.StartRecording();
Console.WriteLine("Started recording. Press ESC to stop...");
while (!(Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.Escape))
{
Thread.Sleep(100);
}
}
catch (Exception)
{
throw;
}
finally
{
Console.WriteLine("Stopping recording...");
recorder.StopRecording();
await call.RequestStream.WriteAsync(new RecognizeRequest { Finish = new Finish() });
}
await call.RequestStream.CompleteAsync();
await responseTask;
}
partial void Modify_RecognizeRequest(ref RecognizeRequest request, ref gaxgrpc::CallSettings settings);
/// <summary> /// Performs synchronous speech recognition: receive results after all audio /// has been sent and processed. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="cancellationToken">A <see cref="st::CancellationToken"/> to use for this RPC.</param> /// <returns>A Task containing the RPC response.</returns> public virtual stt::Task <RecognizeResponse> RecognizeAsync(RecognizeRequest request, st::CancellationToken cancellationToken) => RecognizeAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken));
/// <summary> /// Performs synchronous speech recognition: receive results after all audio /// has been sent and processed. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="callSettings">If not null, applies overrides to this RPC call.</param> /// <returns>A Task containing the RPC response.</returns> public virtual stt::Task <RecognizeResponse> RecognizeAsync(RecognizeRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException();
/// <summary> /// Performs synchronous speech recognition: receive results after all audio /// has been sent and processed. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="callSettings">If not null, applies overrides to this RPC call.</param> /// <returns>The RPC response.</returns> public virtual RecognizeResponse Recognize(RecognizeRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException();
/// <summary>
/// Performs synchronous speech recognition: receive results after all audio
/// has been sent and processed.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// The RPC response.
/// </returns>
public virtual RecognizeResponse Recognize(
RecognizeRequest request,
CallSettings callSettings = null)
{
throw new NotImplementedException();
}
