public string ConvertAudioToText(string path) { var speech = SpeechClient.Create(); var config = new RecognitionConfig { Encoding = RecognitionConfig.Types.AudioEncoding.Flac, SampleRateHertz = 16000, LanguageCode = LanguageCodes.English.UnitedStates }; var audio = RecognitionAudio.FromFile(path); var response = speech.Recognize(config, audio); var sd = ""; foreach (var result in response.Results) { foreach (var alternative in result.Alternatives) { sd += alternative.Transcript; //Console.WriteLine(alternative.Transcript); } } return(sd); }
private void FinishedRecordEventHandler(AudioClip clip) { if (_startRecordButton.interactable) { _speechRecognitionState.color = Color.yellow; } if (clip == null) { return; } RecognitionConfig config = RecognitionConfig.GetDefault(); config.languageCode = ((Enumerators.LanguageCode)_languageDropdown.value).Parse(); config.audioChannelCount = clip.channels; // configure other parameters of the config if need GeneralRecognitionRequest recognitionRequest = new GeneralRecognitionRequest() { audio = new RecognitionAudioContent() { content = clip.ToBase64() }, //audio = new RecognitionAudioUri() // for Google Cloud Storage object //{ // uri = "gs://bucketName/object_name" //}, config = config }; _speechRecognition.Recognize(recognitionRequest); }
//This function calls the google speech api and translate the audio from the path provided. //The text is then returned as a string for more processing //It willl print NO Response if google could not detect anything public string Send_Value(string path) { string file_path = path; RecognitionAudio audio1 = RecognitionAudio.FromFile(file_path); SpeechClient client = SpeechClient.Create(); RecognitionConfig config = new RecognitionConfig { Encoding = RecognitionConfig.Types.AudioEncoding.Linear16, SampleRateHertz = 44100, LanguageCode = LanguageCodes.English.UnitedStates }; RecognizeResponse response = client.Recognize(config, audio1); foreach (var result in response.Results) { foreach (var alternative in result.Alternatives) { Console.WriteLine(alternative.Transcript); } } var output = response.Results; if (output.Count != 0) { var finaloutput = output[0].Alternatives; return(finaloutput[0].Transcript); } else { return("NO RESPONSE"); } }
public void AsyncRecognize() { // Snippet: AsyncRecognize(RecognitionConfig,RecognitionAudio,CallSettings) // Create client SpeechClient speechClient = SpeechClient.Create(); // Initialize request argument(s) RecognitionConfig config = new RecognitionConfig(); RecognitionAudio audio = new RecognitionAudio(); // Make the request Operation <AsyncRecognizeResponse> response = speechClient.AsyncRecognize(config, audio); // Poll until the returned long-running operation is complete Operation <AsyncRecognizeResponse> completedResponse = response.PollUntilCompleted(); // Retrieve the operation result AsyncRecognizeResponse result = completedResponse.Result; // Or get the name of the operation string operationName = response.Name; // This name can be stored, then the long-running operation retrieved later by name Operation <AsyncRecognizeResponse> retrievedResponse = speechClient.PollOnceAsyncRecognize(operationName); // Check if the retrieved long-running operation has completed if (retrievedResponse.IsCompleted) { // If it has completed, then access the result AsyncRecognizeResponse retrievedResult = retrievedResponse.Result; } // End snippet }
internal SpeechRecognizer() { try { client = SpeechClient.Create(); } catch (Exception e) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("SpeechLab server could not start speech recognizer."); Console.WriteLine("Perhaps the GOOGLE_APPLICATION_CREDENTIALS environment variable or the corresponding .json file is missing.\n" + "Correct GOOGLE_APPLICATION_CREDENTIALS environment variable is required to run SpeechLab server.\n\n" + "Full exception message:"); Console.WriteLine(e.Message); Console.WriteLine("\nPress any key to stop the server..."); Console.ReadKey(); Environment.Exit(1); } config = new RecognitionConfig() { Encoding = RecognitionConfig.Types.AudioEncoding.Linear16, SampleRateHertz = 44100, LanguageCode = "ru-Ru" }; }
/// <summary> /// Performs asynchronous speech recognition: receive results via the /// google.longrunning.Operations interface. Returns either an /// `Operation.error` or an `Operation.response` which contains /// a `LongRunningRecognizeResponse` message. /// </summary> /// <param name="config"> /// *Required* Provides information to the recognizer that specifies how to /// process the request. /// </param> /// <param name="audio"> /// *Required* The audio data to be recognized. /// </param> /// <param name="cancellationToken"> /// A <see cref="CancellationToken"/> to use for this RPC. /// </param> /// <returns> /// A Task containing the RPC response. /// </returns> public virtual Task <Operation <LongRunningRecognizeResponse> > LongRunningRecognizeAsync( RecognitionConfig config, RecognitionAudio audio, CancellationToken cancellationToken) => LongRunningRecognizeAsync( config, audio, CallSettings.FromCancellationToken(cancellationToken));
private void RecognizeFile(string file) { if (string.IsNullOrEmpty(file)) { MessageBox.Show("Please select a wav file first!"); return; } if (File.Exists(file) == false) { MessageBox.Show("Specified WAV file is NOT exist! Please try to select another file..."); return; } SpeechClient client = SpeechClient.Create(); RecognitionConfig config = new RecognitionConfig() { Encoding = RecognitionConfig.Types.AudioEncoding.Linear16, SampleRateHertz = 8000, LanguageCode = "zh-TW", }; RecognitionAudio audio = RecognitionAudio.FromFile(file); var response = client.Recognize(config, audio); foreach (var item in response.Results) { textBox2.AppendLine(item.ToString()); } }
public static void HandleRecognitionCommand( uint sampleRate, string audioEncoding, uint channelsCount, uint maxAlternatives, bool disableAutomaticPunctation, bool doNotPerformVad, float silenceDurationThreshold, string audioPath ) { RecognitionConfig recognitionConfig = CreateRecognitionConfig( sampleRate, audioEncoding, channelsCount, maxAlternatives, disableAutomaticPunctation ); ConfigurateVAD( recognitionConfig, silenceDurationThreshold, doNotPerformVad ); using (var fileStream = GetAudioStream(audioPath, audioEncoding)) { System.Console.WriteLine(_client.Recognize(recognitionConfig, fileStream)); } }
public VoiceManager() { var outputFolder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "NAudio"); Directory.CreateDirectory(outputFolder); outputFilePath = Path.Combine(outputFolder, "recorded.wav"); waveIn = new WaveInEvent(); waveIn.WaveFormat = new WaveFormat(44100, 16, 1); waveIn.DataAvailable += waveIn_DataAvailable; waveIn.RecordingStopped += waveIn_RecordingStopped; writer = null; max_v = 0; isWriting = false; TimeDelay = 1; //seconds strRecgnResult = ""; IdleTimeAmount = 10; //seconds isResultRecieved = false; isRecordStarted = false; speech = SpeechClient.Create(); config = new RecognitionConfig { LanguageCode = LanguageCodes.Russian.Russia }; }
public RecognizeResponse translate([FromBody] string filename) { string path = "C:\\Users\\Dell\\Downloads\\" + filename; RecognitionAudio audio = RecognitionAudio.FromFile(path); //RecognitionAudio audio2 = RecognitionAudio.FetchFromUri("https://storage.googleapis.com/cloud-samples-tests/speech/brooklyn.flac"); //RecognitionAudio audio3 = RecognitionAudio.FromStorageUri("gs://my-bucket/my-file"); /* byte[] bytes = ReadAudioData(); // For example, from a database * RecognitionAudio audio4 = RecognitionAudio.FromBytes(bytes); * * using (Stream stream = OpenAudioStream()) // Any regular .NET stream * { * RecognitionAudio audio5 = RecognitionAudio.FromStream(stream); * }*/ SpeechClient client = SpeechClient.Create(); RecognitionConfig config = new RecognitionConfig { Encoding = AudioEncoding.Linear16, SampleRateHertz = 48000, LanguageCode = LanguageCodes.English.UnitedStates }; RecognizeResponse response = client.Recognize(config, audio); return(response); }
/// <summary> /// Sends the voice audio to Google's API and runs HandleSpeech with transcription. /// </summary> private void TranscribeSpeech(Message m) { if (m.voice == null) { throw new Exception.EmptyVoiceMessageException(m); } if (m.voice.Duration > maxDur) { MaxDurationExceeded(m); return; } SpeechClient speech = SpeechClient.Create(); RecognitionConfig config = new RecognitionConfig(); config.Encoding = SpeechHandler.VoiceTypeToGoogleType(m.voice.type); config.SampleRateHertz = m.voice.sampleRate; config.LanguageCode = languageCode; config.ProfanityFilter = false; RecognizeResponse resp = speech.Recognize(config, RecognitionAudio.FromStream(m.voice.AudioStream)); foreach (var result in resp.Results) { foreach (var alternative in result.Alternatives) { HandleSpeech(m, alternative.Transcript); } } }
private SpeechRecognizer(FileInfo secret) { if (secret is null) { throw new ArgumentNullException(nameof(secret)); } if (!secret.Exists) { throw new FileNotFoundException("secret file not found.", secret.FullName); } var credential = GoogleCredential.FromFile(secret.FullName); var channel = new Channel(SpeechClient.DefaultEndpoint.Host, credential.ToChannelCredentials()); this._speech = SpeechClient.Create(channel); this._config = new RecognitionConfig { Encoding = RecognitionConfig.Types.AudioEncoding.Linear16, SampleRateHertz = 16_000, LanguageCode = Thread.CurrentThread.CurrentCulture.Name, }; this._recorder = new WaveRecorder(); this._recorder.Completed += this.OnComplete; }
/// <summary> /// Informa o servidor ASR de que se deseja realizar o reconhecimento de um buffer /// </summary> /// <param name="lModel">Modelo de linguagem a ser utilizado</param> /// <param name="objRecognitionConfig">Parametro a serem setados apenas para este reconhecimento</param> /// <param name="dicParameters">Parametro a serem setados apenas para este reconhecimento</param> public void StartRecognition(LanguageModel lModel, RecognitionConfig objRecognitionConfig) { WriteLog(string.Concat("Thread Id: ", Thread.CurrentThread.ManagedThreadId)); StringBuilder strCommand = new StringBuilder(); strCommand.AppendLine(string.Format("{0} {1} {2}", PRODUCT, VERSION, ASR_Command.START_RECOGNITION)); //Insere os valores dos parametros configurados if (objRecognitionConfig != null) { strCommand.AppendLine(GetCommand(objRecognitionConfig)); } if (lModel?.Uri != null) { strCommand.AppendLine(string.Concat("Content-Length: ", lModel.Uri.Length + 8)); strCommand.AppendLine("Content-Type: " + TEXT_URI_LIST); strCommand.AppendLine(); strCommand.AppendLine(lModel.Uri); } else if (lModel?.Definition != null) { strCommand.AppendLine("Content-ID: " + lModel.Id); strCommand.AppendLine(string.Concat("Content-Length: ", lModel.Definition.Length + 8)); strCommand.AppendLine("Content-Type: " + APPLICATION_SRGS); strCommand.AppendLine(); strCommand.AppendLine(lModel.Definition); } WriteLog("Start Recognition"); SendCommand(strCommand.ToString()); }
public static string StartTranslate(string path, string lang) { var builder = new SpeechClientBuilder(); builder.CredentialsPath = "key.json"; var speech = builder.Build(); var config = new RecognitionConfig { Encoding = RecognitionConfig.Types.AudioEncoding.Linear16, LanguageCode = lang, AudioChannelCount = 1 }; var audio = RecognitionAudio.FromFile(path); var response = speech.Recognize(config, audio); string fullText = ""; foreach (var result in response.Results) { foreach (var alternative in result.Alternatives) { fullText += alternative.Transcript; } } return(fullText); }
public void NoInputTimeOut() { var recogConfig = new RecognitionConfig { NoInputTimeoutMilliseconds = 200, NoInputTimeoutEnabled = true }; var clientConfig = CreateClientWithCredentials(recogConfig, TestsReferences.DefaultASRURL, TestsReferences.User, TestsReferences.Password); var lModelLst = new LanguageModelList(); lModelLst.AddFromUri(TestsReferences.FreeLanguageModel); var audioSource = new FileAudioSource(TestsReferences.AudioSilence, AudioType.DETECT); List <RecognitionResult> results = null; try { lModelLst.AddFromUri(TestsReferences.FreeLanguageModel); results = ExecuteRecognition(clientConfig, lModelLst, audioSource); } catch (Exception ex) { throw new InternalTestFailureException(ex.Message); } Assert.IsTrue(results != null && results.Count > 0); Assert.AreEqual(RecognitionResultCode.NO_INPUT_TIMEOUT, results[0].ResultCode); }
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)); }
/// <summary>Snippet for LongRunningRecognizeAsync</summary> public async Task LongRunningRecognizeAsync() { // Snippet: LongRunningRecognizeAsync(RecognitionConfig, RecognitionAudio, CallSettings) // Additional: LongRunningRecognizeAsync(RecognitionConfig, RecognitionAudio, CancellationToken) // Create client SpeechClient speechClient = await SpeechClient.CreateAsync(); // Initialize request argument(s) RecognitionConfig config = new RecognitionConfig(); RecognitionAudio audio = new RecognitionAudio(); // Make the request Operation <LongRunningRecognizeResponse, LongRunningRecognizeMetadata> response = await speechClient.LongRunningRecognizeAsync(config, audio); // Poll until the returned long-running operation is complete Operation <LongRunningRecognizeResponse, LongRunningRecognizeMetadata> completedResponse = await response.PollUntilCompletedAsync(); // Retrieve the operation result LongRunningRecognizeResponse result = completedResponse.Result; // Or get the name of the operation string operationName = response.Name; // This name can be stored, then the long-running operation retrieved later by name Operation <LongRunningRecognizeResponse, LongRunningRecognizeMetadata> retrievedResponse = await speechClient.PollOnceLongRunningRecognizeAsync(operationName); // Check if the retrieved long-running operation has completed if (retrievedResponse.IsCompleted) { // If it has completed, then access the result LongRunningRecognizeResponse retrievedResult = retrievedResponse.Result; } // End snippet }
public static int Main(string[] args) { // Create client SpeechClient client = SpeechClient.Create(); // Initialize request argument(s) RecognitionConfig config = new RecognitionConfig { LanguageCode = "en-US", SampleRateHertz = 44100, Encoding = RecognitionConfig.Types.AudioEncoding.Flac, }; RecognitionAudio audio = new RecognitionAudio { Uri = "gs://gapic-toolkit/hello.flac", }; // Call API method RecognizeResponse response = client.Recognize(config, audio); // Show the result Console.WriteLine(response); // Success Console.WriteLine("Smoke test passed OK"); return(0); }
public void Start(RecognitionConfig config) { _config = config.Windows; _stream = new PipeStream(9600); if (_speechEngine == null) { _speechEngine = new SpeechRecognitionEngine(); _speechEngine.LoadGrammar(new DictationGrammar()); _speechEngine.SpeechHypothesized += OnSpeechHypothesized; _speechEngine.SpeechRecognized += OnSpeechRecognized; } var format = new SpeechAudioFormatInfo(48000, AudioBitsPerSample.Sixteen, AudioChannel.Mono); _speechEngine.SetInputToAudioStream(_stream, format); if (!_recognizing) { _recognizing = true; _speaking = false; _speechEngine.RecognizeAsync(RecognizeMode.Multiple); } }
/// <summary> /// Perform asynchronous speech-recognition: receive results via the /// google.longrunning.Operations interface. Returns either an /// `Operation.error` or an `Operation.response` which contains /// an `AsyncRecognizeResponse` message. /// </summary> /// <param name="config"> /// [Required] The `config` message provides information to the recognizer /// that specifies how to process the request. /// </param> /// <param name="audio"> /// [Required] The audio data to be recognized. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// The RPC response. /// </returns> public virtual Operation AsyncRecognize( RecognitionConfig config, RecognitionAudio audio, CallSettings callSettings = null) { throw new NotImplementedException(); }
static object RecognizeWithContext(string filePath, IEnumerable <string> phrases) { var speech = SpeechClient.Create(); var config = new RecognitionConfig() { SpeechContexts = { new SpeechContext() { Phrases ={ phrases } } }, Encoding = RecognitionConfig.Types.AudioEncoding.Linear16, SampleRateHertz = 16000, LanguageCode = "en", }; var audio = IsStorageUri(filePath) ? RecognitionAudio.FromStorageUri(filePath) : RecognitionAudio.FromFile(filePath); var response = speech.Recognize(config, audio); foreach (var result in response.Results) { foreach (var alternative in result.Alternatives) { Console.WriteLine(alternative.Transcript); } } return(0); }
/// <summary> /// Perform synchronous speech-recognition: receive results after all audio /// has been sent and processed. /// </summary> /// <param name="config"> /// [Required] The `config` message provides information to the recognizer /// that specifies how to process the request. /// </param> /// <param name="audio"> /// [Required] The audio data to be recognized. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// A Task containing the RPC response. /// </returns> public virtual Task <SyncRecognizeResponse> SyncRecognizeAsync( RecognitionConfig config, RecognitionAudio audio, CallSettings callSettings = null) { throw new NotImplementedException(); }
/// <summary> /// Perform asynchronous speech-recognition: receive results via the /// google.longrunning.Operations interface. Returns either an /// `Operation.error` or an `Operation.response` which contains /// an `AsyncRecognizeResponse` message. /// </summary> /// <param name="config"> /// [Required] The `config` message provides information to the recognizer /// that specifies how to process the request. /// </param> /// <param name="audio"> /// [Required] The audio data to be recognized. /// </param> /// <param name="cancellationToken"> /// A <see cref="CancellationToken"/> to use for this RPC. /// </param> /// <returns> /// A Task containing the RPC response. /// </returns> public virtual Task <Operation> AsyncRecognizeAsync( RecognitionConfig config, RecognitionAudio audio, CancellationToken cancellationToken) => AsyncRecognizeAsync( config, audio, CallSettings.FromCancellationToken(cancellationToken));
/// <summary> /// Performs asynchronous speech recognition: receive results via the /// google.longrunning.Operations interface. Returns either an /// `Operation.error` or an `Operation.response` which contains /// a `LongRunningRecognizeResponse` message. /// </summary> /// <param name="config"> /// *Required* Provides information to the recognizer that specifies how to /// process the request. /// </param> /// <param name="audio"> /// *Required* The audio data to be recognized. /// </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 <lro::Operation <LongRunningRecognizeResponse, LongRunningRecognizeMetadata> > LongRunningRecognizeAsync( RecognitionConfig config, RecognitionAudio audio, st::CancellationToken cancellationToken) => LongRunningRecognizeAsync( config, audio, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken));
/// <summary> /// Performs synchronous speech recognition: receive results after all audio /// has been sent and processed. /// </summary> /// <param name="config"> /// *Required* Provides information to the recognizer that specifies how to /// process the request. /// </param> /// <param name="audio"> /// *Required* The audio data to be recognized. /// </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( RecognitionConfig config, RecognitionAudio audio, st::CancellationToken cancellationToken) => RecognizeAsync( config, audio, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken));
/// <summary> /// Performs asynchronous speech recognition: receive results via the /// google.longrunning.Operations interface. Returns either an /// `Operation.error` or an `Operation.response` which contains /// a `LongRunningRecognizeResponse` message. /// </summary> /// <param name="config"> /// *Required* Provides information to the recognizer that specifies how to /// process the request. /// </param> /// <param name="audio"> /// *Required* The audio data to be recognized. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// The RPC response. /// </returns> public virtual lro::Operation <LongRunningRecognizeResponse, LongRunningRecognizeMetadata> LongRunningRecognize( RecognitionConfig config, RecognitionAudio audio, gaxgrpc::CallSettings callSettings = null) => LongRunningRecognize( new LongRunningRecognizeRequest { Config = gax::GaxPreconditions.CheckNotNull(config, nameof(config)), Audio = gax::GaxPreconditions.CheckNotNull(audio, nameof(audio)), }, callSettings);
/// <summary> /// Performs synchronous speech recognition: receive results after all audio /// has been sent and processed. /// </summary> /// <param name="config"> /// *Required* Provides information to the recognizer that specifies how to /// process the request. /// </param> /// <param name="audio"> /// *Required* The audio data to be recognized. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// The RPC response. /// </returns> public virtual RecognizeResponse Recognize( RecognitionConfig config, RecognitionAudio audio, gaxgrpc::CallSettings callSettings = null) => Recognize( new RecognizeRequest { Config = gax::GaxPreconditions.CheckNotNull(config, nameof(config)), Audio = gax::GaxPreconditions.CheckNotNull(audio, nameof(audio)), }, callSettings);
/// <summary> /// Performs asynchronous speech recognition: receive results via the /// google.longrunning.Operations interface. Returns either an /// `Operation.error` or an `Operation.response` which contains /// a `LongRunningRecognizeResponse` message. /// </summary> /// <param name="config"> /// *Required* Provides information to the recognizer that specifies how to /// process the request. /// </param> /// <param name="audio"> /// *Required* The audio data to be recognized. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// A Task containing the RPC response. /// </returns> public virtual Task <Operation <LongRunningRecognizeResponse, LongRunningRecognizeMetadata> > LongRunningRecognizeAsync( RecognitionConfig config, RecognitionAudio audio, CallSettings callSettings = null) => LongRunningRecognizeAsync( new LongRunningRecognizeRequest { Config = GaxPreconditions.CheckNotNull(config, nameof(config)), Audio = GaxPreconditions.CheckNotNull(audio, nameof(audio)), }, callSettings);
/// <summary> /// Performs synchronous speech recognition: receive results after all audio /// has been sent and processed. /// </summary> /// <param name="config"> /// *Required* Provides information to the recognizer that specifies how to /// process the request. /// </param> /// <param name="audio"> /// *Required* The audio data to be recognized. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// A Task containing the RPC response. /// </returns> public virtual Task <RecognizeResponse> RecognizeAsync( RecognitionConfig config, RecognitionAudio audio, CallSettings callSettings = null) => RecognizeAsync( new RecognizeRequest { Config = GaxPreconditions.CheckNotNull(config, nameof(config)), Audio = GaxPreconditions.CheckNotNull(audio, nameof(audio)), }, callSettings);
/// <summary> /// Perform asynchronous speech-recognition: receive results via the /// google.longrunning.Operations interface. Returns either an /// `Operation.error` or an `Operation.response` which contains /// an `AsyncRecognizeResponse` message. /// </summary> /// <param name="config"> /// [Required] The `config` message provides information to the recognizer /// that specifies how to process the request. /// </param> /// <param name="audio"> /// [Required] The audio data to be recognized. /// </param> /// <param name="callSettings"> /// If not null, applies overrides to this RPC call. /// </param> /// <returns> /// The RPC response. /// </returns> public virtual Operation <AsyncRecognizeResponse> AsyncRecognize( RecognitionConfig config, RecognitionAudio audio, CallSettings callSettings = null) => AsyncRecognize( new AsyncRecognizeRequest { Config = config, Audio = audio, }, callSettings);