/// <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> /// Sends a speech recognition request to the speech service /// </summary> /// <param name="audioFile">The audio file.</param> /// <param name="locale">The locale.</param> /// <param name="serviceUrl">The service URL.</param> /// <param name="subscriptionKey">The subscription key.</param> /// <returns> /// A task /// </returns> public async Task Run(string audioFile, string locale, Uri serviceUrl, string subscriptionKey, string resultFile) { // create the preferences object var preferences = new Preferences(locale, serviceUrl, new CognitiveServicesAuthorizationProvider(subscriptionKey)); ResultFile = resultFile; File.CreateText(ResultFile); // Create a a speech client using (var speechClient = new SpeechClient(preferences)) { speechClient.SubscribeToPartialResult(this.OnPartialResult); speechClient.SubscribeToRecognitionResult(this.OnRecognitionResult); // create an audio content and pass it a stream. using (var audio = new FileStream(audioFile, FileMode.Open, FileAccess.Read)) { var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Ethernet, OsName.Windows, "1607", "Dell", "T3600"); var applicationMetadata = new ApplicationMetadata("SampleApp", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "SampleAppService"); await speechClient.RecognizeAsync(new SpeechInput(audio, requestMetadata), this.cts.Token).ConfigureAwait(false); } } }
public async Task DecodeAudioAsync( Stream stream, string locale, PhraseMode mode, Func <RecognitionStep, Task> partialResult, Func <RecognitionFinalResult, Task> finalResult) { var serviceUrl = (mode == PhraseMode.LongDictation ? LongDictationUrl : ShortPhraseUrl); string subscriptionKey = configuration.GetSection("AudioToTextService.Core.AudioDecoder")["subscriptionKey"]; // create the preferences object var preferences = new Preferences(locale, serviceUrl, new CognitiveServicesAuthorizationProvider(subscriptionKey)); // Create a a speech client using (var speechClient = new SpeechClient(preferences)) { speechClient.SubscribeToPartialResult((args) => { return(partialResult(ToStep(args))); }); speechClient.SubscribeToRecognitionResult((args) => { return(finalResult(ToFinalResult(args))); }); // create an audio content and pass it a stream. var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Ethernet, OsName.Windows, "1607", "Dell", "T3600"); var applicationMetadata = new ApplicationMetadata("SampleApp", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "SampleAppService"); await speechClient.RecognizeAsync(new SpeechInput(stream, requestMetadata), this.cts.Token).ConfigureAwait(false); } }
/// <summary> /// 通过语音数据识别语音内容 /// </summary> /// <param name="audioBytes">语音数据</param> /// <param name="locale">语种</param> /// <returns></returns> public async Task RunDiscernAsBytes(byte[] audioBytes, string locale) { Uri serviceUrl = ShortUrl; if (GetWavPlayTime(audioBytes) > 15) { serviceUrl = LongUrl; } var preferences = new Preferences(locale, serviceUrl, new AsrCheckKeyProvider(apiKey)); //参数配置类 using (var speechClient = new SpeechClient(preferences)) //创建语音客户端 { speechClient.SubscribeToPartialResult(this.OnPartialResult); speechClient.SubscribeToRecognitionResult(this.OnRecognitionResult); using (Stream stream = new MemoryStream(audioBytes)) { var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Ethernet, OsName.Windows, "1607", "Dell", "T3600"); var applicationMetadata = new ApplicationMetadata("SampleApp", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "SampleAppService"); try { await speechClient.RecognizeAsync(new SpeechInput(stream, requestMetadata), this.cts.Token).ConfigureAwait(false); } catch (Exception ex) { } } } }
private Task <Tuple <string, string> > transcribeAudioSegement(int index, string fileName, string audioFile, TimeSpan totalTime, CancellationToken token, string user) { return(Task.Factory.StartNew <Tuple <string, string> >(() => { //var preferences = new Preferences("en-US", new Uri("wss://speech.platform.bing.com/api/service/recognition/continuous"), new CognitiveServicesAuthorizationProvider("68ecbfed77384b0badae81995a5b256b")); var preferences = new Preferences("en-US", new Uri("wss://5ba5d066af03405ba71e84ba3bc4d185.api.cris.ai/ws/cris/speech/recognize/continuous"), new CognitiveServicesAuthorizationProvider("36677b4f10da4d2a946af66da757ef0b")); DateTime lastReportTime = DateTime.Now; DateTime lastDetectionTime = DateTime.Now; int runonLength = 0; StringBuilder text = new StringBuilder(); using (var speechClient = new SpeechClient(preferences)) { speechClient.SubscribeToPartialResult((args) => { return Task.Factory.StartNew(() => { token.ThrowIfCancellationRequested(); if (DateTime.Now - lastReportTime >= mReportInterval) { var percent = (int)(args.MediaTime * 0.00001 / totalTime.TotalSeconds); percentages[index] = percent; reportProgress(fileName, Math.Min(99, percentages.Sum()), args.DisplayText.Substring(0, Math.Min(args.DisplayText.Length, 50)) + "...", user).Wait(); lastReportTime = DateTime.Now; } }); }); speechClient.SubscribeToRecognitionResult((args) => { return Task.Factory.StartNew(() => { if (args.Phrases.Count > 0) { string bestText = args.Phrases[args.Phrases.Count - 1].DisplayText; runonLength += bestText.Length; if ((DateTime.Now - lastDetectionTime >= TimeSpan.FromSeconds(5) || runonLength >= 1800) && runonLength >= 250) { text.Append("\r\n\r\n "); runonLength = 0; } text.Append(Regex.Replace(bestText, "(?<=[\\.,?])(?![$ ])", " ")); lastDetectionTime = DateTime.Now; } }); }); using (var audio = new FileStream(audioFile, FileMode.Open, FileAccess.Read)) { var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Ethernet, OsName.Windows, "1607", "Dell", "T3600"); var applicationMetadata = new ApplicationMetadata("TranscriptionApp", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "TranscriptionService"); speechClient.RecognizeAsync(new SpeechInput(audio, requestMetadata), mTokensource.Token).Wait(); return new Tuple <string, string>(audioFile, text.ToString()); } } })); }
public static async Task <string> ReconhecerFala(string contentUrl) { RecognitionStatus status = RecognitionStatus.None; string stringResult = string.Empty; WebClient wc = new WebClient(); OgaToWavConverter converter = new OgaToWavConverter(); var ogaData = await wc.DownloadDataTaskAsync(contentUrl); var wavData = converter.Convert(ogaData); var preferences = new Preferences("pt-BR", new Uri(@"wss://speech.platform.bing.com/api/service/recognition"), new CognitiveServicesAuthorizationProvider(CognitiveServicesAuthorizationProvider.API_KEY)); using (var speechClient = new SpeechClient(preferences)) { speechClient.SubscribeToPartialResult( result => { stringResult = result.DisplayText; return(Task.FromResult(true)); }); speechClient.SubscribeToRecognitionResult( result => { status = result.RecognitionStatus; return(Task.FromResult(true)); }); var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Unknown, NetworkType.Unknown, OsName.Windows, "10", "IBM", "ThinkCenter"); var applicationMetadata = new ApplicationMetadata("WorkshopAtentoBot", "1.0"); var requestMetada = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "ReconhecimentoFalaService"); await speechClient.RecognizeAsync(new SpeechInput(new MemoryStream(wavData), requestMetada), CancellationToken.None).ConfigureAwait(false); } while (status == RecognitionStatus.None) { await Task.Delay(200); } if (status == RecognitionStatus.Success) { return(stringResult); } else { return($"Ocorreu um erro no reconhecimento de fala. Status = {status}"); } }
private void StartSpeechRecognition() { _recognitionCts = new CancellationTokenSource(); string speechSubscription = Service.Instance.Configuration.SpeechSubscription; Preferences preferences = new Preferences("en-US", LongDictationUrl, new CognitiveServicesAuthorizationProvider(speechSubscription), enableAudioBuffering: false); _recognitionStream = new SpeechRecognitionPcmStream(16000); var deviceMetadata = new DeviceMetadata(DeviceType.Far, DeviceFamily.Unknown, NetworkType.Unknown, OsName.Windows, "1607", "Dell", "T3600"); var applicationMetadata = new ApplicationMetadata("HueBot", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "HueBot"); Task.Run(async() => { do { try { //create a speech client using (_speechClient = new SpeechClient(preferences)) { _speechClient.SubscribeToRecognitionResult(this.OnRecognitionResult); await _speechClient.RecognizeAsync(new SpeechInput(_recognitionStream, requestMetadata), _recognitionCts.Token); } Log.Info(new CallerInfo(), LogContext.Media, $"[{this.Id}]: Speech recognize completed."); } catch (Exception exception) { Log.Error(new CallerInfo(), LogContext.Media, $"[{this.Id}]: Speech recognize threw exception {exception.ToString()}"); } if (_recognitionCts.IsCancellationRequested) { Log.Info(new CallerInfo(), LogContext.Media, $"[{this.Id}]:Speech recognition cancelled because it was cancelled or max exception count was hit"); break; } Stream oldStream = _recognitionStream; Log.Info(new CallerInfo(), LogContext.Media, $"[{this.Id}]: Restart speech recognition as the call is still alive. Speech recognition could have been completed because of babble/silence timeout"); _recognitionStream = new SpeechRecognitionPcmStream(16000); oldStream.Dispose(); } while (true); _speechRecoginitionFinished.Set(); } ).ForgetAndLogException(string.Format("Failed to start the SpeechRecognition Task for Id: {0}", Id)); }
/// <summary> /// Takes a passed in file that is assumed to be mono and PCM encoded, /// and sends it to the speech client. /// </summary> /// <param name="audioFile">The full path and file name of a PCM encoded MONO channel file.</param> /// <returns></returns> public async Task ExecuteRecogniseAsync(string audioFile) { FileInfo inputFileInfo = new FileInfo(audioFile); WaveStream audioStream = null; Mp3FileReader mp3Stream = null; string tempAudioFile = audioFile; switch (inputFileInfo.Extension.ToLower()) { case ".mp3": mp3Stream = new Mp3FileReader(audioFile); audioStream = WaveFormatConversionStream.CreatePcmStream(mp3Stream); // Have to send to a physical file, as the NAudio stream doesn't interact with the // Speech client nicely. tempAudioFile = System.IO.Path.GetTempFileName(); WaveFileWriter.CreateWaveFile(tempAudioFile, audioStream); break; default: // Try and send the file to the speechClient, in the hope it is a PCM encoded file. break; } //using (var inputReader = new AudioFileReader(audioFile)) //{ // var mono = inputReader.ToMono(0.5f, 0.5f); //} // Create a a speech client using (var speechClient = new SpeechClient(this._preferences)) { speechClient.SubscribeToRecognitionResult(this.OnRecognitionResultAsync); var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Ethernet, OsName.Windows, "1607", "HyperV", "HyperV"); var applicationMetadata = new ApplicationMetadata("SSISSpeachToText", "1.0.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "SQL Server Integration Services"); using (var audio = new FileStream(tempAudioFile, FileMode.Open, FileAccess.Read)) await speechClient.RecognizeAsync(new SpeechInput(audio, requestMetadata), this.cts.Token).ConfigureAwait(false); } if (audioStream != null) { audioStream.Dispose(); } if (mp3Stream != null) { mp3Stream.Dispose(); } }
/// <summary>Snippet for RecognizeAsync</summary> public async Task RecognizeAsync() { // Snippet: RecognizeAsync(RecognitionConfig, RecognitionAudio, CallSettings) // Additional: RecognizeAsync(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 RecognizeResponse response = await speechClient.RecognizeAsync(config, audio); // End snippet }
public async Task <string> RecognizeFromFile(byte[] audio) { if (_disabled) { return("Speech recognition is currently disabled"); } var recognitionAudio = RecognitionAudio.FromBytes(audio); RecognizeResponse response = await _speechClient.RecognizeAsync(_config, recognitionAudio); var recognized = response.Results .SelectMany(result => result.Alternatives.Select(alternative => alternative.Transcript)) .Aggregate((x, y) => x + " " + y); return(recognized); }
public async Task <List <string> > DoRequest(Stream audioFile) { CancellationTokenSource cts = new CancellationTokenSource(); var preferences = new Preferences(_locale, _serviceUrl, new CognitiveServicesAuthorizationProvider(_subscriptionKey)); using (var speechClient = new SpeechClient(preferences)) { speechClient.SubscribeToRecognitionResult(this.OnRecognitionResult); var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Ethernet, OsName.Windows, "1607", "Dell", "T3600"); var applicationMetadata = new ApplicationMetadata("SampleApp", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "SampleAppService"); await speechClient.RecognizeAsync(new SpeechInput(audioFile, requestMetadata), cts.Token).ConfigureAwait(false); } return(_lines); }
public async Task <string> RecognizeFile(Stream audio, string stsUrl, string authKey, Uri longDictationUrl) { var cts = new CancellationTokenSource(); // create the preferences object var preferences = new Preferences("en-US", longDictationUrl, new CognitiveServicesAuthorizationProvider(stsUrl, authKey)); List <RecognitionResult> results = new List <RecognitionResult>(); using (var speechClient = new SpeechClient(preferences)) { speechClient.SubscribeToRecognitionResult(async(rr) => { await Task.Run(() => { results.Add(rr); Console.WriteLine("--------------------------------------------"); Console.WriteLine($"RecognitionStatus = ${rr.RecognitionStatus}"); foreach (var p in rr.Phrases) { Console.WriteLine($" {p.Confidence} {p.DisplayText}"); } }); }); var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Unknown, OsName.Unknown, "1607", "Azure", "Function"); var applicationMetadata = new ApplicationMetadata("ResilientLongVtt", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "SampleAppService"); await speechClient.RecognizeAsync(new SpeechInput(audio, requestMetadata), cts.Token); Console.Write($"TOTAL RESULTS : {results.Count}"); } return("rien"); }
/// <summary> /// Sends a speech recognition request to the speech service /// </summary> /// <param name="audioFile">The audio file.</param> /// <param name="locale">The locale.</param> /// <returns> /// A task /// </returns> public async Task <string> TranslateToText(string audioFile, string locale = "en-GB") { var preferences = new Preferences(locale, _serviceUrl, new CognitiveServicesAuthorizationProvider(_subscriptionKey)); // Create a a speech client using (var speechClient = new SpeechClient(preferences)) { speechClient.SubscribeToPartialResult(this.OnPartialResult); speechClient.SubscribeToRecognitionResult(this.OnRecognitionResult); try { // create an audio content and pass it a stream. using (var downloadStream = new WebClient()) using (var audio = new MemoryStream(downloadStream.DownloadData(audioFile))) { var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Ethernet, OsName.Windows, "1607", "Dell", "T3600"); var applicationMetadata = new ApplicationMetadata("SampleApp", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "SampleAppService"); await speechClient.RecognizeAsync(new SpeechInput(audio, requestMetadata), this.cts.Token) .ConfigureAwait(false); } } catch (Exception e) { if (e is PlatformNotSupportedException) { return(await TranslateToTextFallback(audioFile).ConfigureAwait(false)); //fallback for when websockets are not supported } } } return(string.Empty); }
/// <summary> /// Sends a speech recognition request to the speech service /// </summary> /// <param name="audioFile">The audio file.</param> /// <param name="locale">The locale.</param> /// <param name="serviceUrl">The service URL.</param> /// <param name="subscriptionKey">The subscription key.</param> /// <returns> /// A task /// </returns> /// public async Task Run(string audioFile, string locale, Uri serviceUrl, string subscriptionKey, string episode) { // create the preferences object var preferences = new Preferences(locale, serviceUrl, new CognitiveServicesAuthorizationProvider(subscriptionKey)); string simpleFilename = Path.GetFileNameWithoutExtension(audioFile); if (int.TryParse(episode, out int outepisode)) { episodenumber = outepisode; } else { return; } htmlOutputFilePath = Path.GetDirectoryName(audioFile) + @"\" + episodenumber.ToString() + ".html"; opmlOutputFilePath = Path.GetDirectoryName(audioFile) + @"\" + episodenumber.ToString() + ".opml"; // Create a a speech client using (var speechClient = new SpeechClient(preferences)) { //speechClient.SubscribeToPartialResult(this.OnPartialResult); speechClient.SubscribeToRecognitionResult(this.OnRecognitionResult); // create an audio content and pass it a stream. using (var audio = new FileStream(audioFile, FileMode.Open, FileAccess.Read)) { var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Ethernet, OsName.Windows, "1607", "Dell", "T3600"); var applicationMetadata = new ApplicationMetadata("NA Transcribe", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "NATranscriptService"); await speechClient.RecognizeAsync(new SpeechInput(audio, requestMetadata), this.cts.Token).ConfigureAwait(false); } } }
/// <summary> /// Sends a speech recognition request to the speech service /// </summary> /// <param name="audioFile">The audio file.</param> /// <param name="locale">The locale.</param> /// <param name="serviceUrl">The service URL.</param> /// <param name="subscriptionKey">The subscription key.</param> /// <returns> /// A task /// </returns> public async Task Run() { // create the preferences object var preferences = new Preferences("en-US", LongDictationUrl, new CognitiveServicesAuthorizationProvider("c26f94bbc00e4c98a0ee0cde5833506a")); // Create a a speech client using (var speechClient = new SpeechClient(preferences)) { //speechClient.SubscribeToPartialResult(this.OnPartialResult); speechClient.SubscribeToRecognitionResult(this.OnRecognitionResult); // create an audio content and pass it a stream. using (var audio = new FileStream(filename, FileMode.Open, FileAccess.Read)) { var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Ethernet, OsName.Windows, "1607", "Dell", "T3600"); var applicationMetadata = new ApplicationMetadata("SampleApp", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "SampleAppService"); await speechClient.RecognizeAsync(new SpeechInput(audio, requestMetadata), this.cts.Token).ConfigureAwait(false); } } // Create a client. ITextAnalyticsAPI client = new TextAnalyticsAPI(); client.AzureRegion = AzureRegions.Westcentralus; client.SubscriptionKey = "922da2349b3f4d5f8d30cf175347ce7b"; SentimentBatchResult result3 = client.Sentiment( new MultiLanguageBatchInput( new List <MultiLanguageInput>() { new MultiLanguageInput("en", "0", Msg), })); // Printing sentiment results var document = result3.Documents[result3.Documents.Count() - 1]; StringBuilder sb = new StringBuilder(); sb.AppendFormat("Sentiment Score: {0:0.00}", document.Score); //Save to DB string sql = "update [CaseConversation] set [ConversationTranscript] = '" + Msg + "',"; sql += "[SentimentScore] = " + document.Score + " where id = " + sqlInt + ";"; using (SqlConnection conn = new SqlConnection(ConfigurationManager.AppSettings["DBConnectionString"])) { // 1. declare command object with parameter conn.Open(); SqlCommand cmd = conn.CreateCommand(); cmd.CommandText = sql; // 2. define parameters used in command object //SqlParameter param = new SqlParameter(); //param.ParameterName = "@qkid"; //param.Value = "''"; // 3. add new parameter to command object //cmd.Parameters.Add(param); int sqlInt2 = cmd.ExecuteNonQuery(); cmd.Dispose(); conn.Close(); } Msg += "<br /> <br />" + sb.ToString(); }
private async Task OnBinaryMessageReceived(WebSocketHandler handler, byte[] bytes, string conversationId, string watermark) { string replyMessage = null; // Convert speech to text try { using (var speechClient = new SpeechClient(this.speechPreference)) { speechClient.SubscribeToRecognitionResult(this.OnRecognitionResult); // create an audio content and pass it a stream. using (MemoryStream audioStream = new MemoryStream(bytes)) { var deviceMetadata = new DeviceMetadata(DeviceType.Near, DeviceFamily.Desktop, NetworkType.Wifi, OsName.Windows, "1607", "Dell", "T3600"); var applicationMetadata = new ApplicationMetadata("SampleApp", "1.0.0"); var requestMetadata = new RequestMetadata(Guid.NewGuid(), deviceMetadata, applicationMetadata, "SampleAppService"); await speechClient.RecognizeAsync(new SpeechInput(PCMToWAV(audioStream), requestMetadata), this.cts.Token).ConfigureAwait(false); } } } catch (Exception e) { //throw new DemoBotServiceException($"Convert text to speech failed: {e.Message}"); } // await handler.SendMessage($"You said: {this.speechText}"); if (!string.IsNullOrEmpty(speechText)) { // Send text message to Bot Service await BotClientHelper.SendBotMessageAsync(this.directLineClient, conversationId, FromUserId, speechText); BotMessage botResponse = await BotClientHelper.ReceiveBotMessagesAsync(this.directLineClient, conversationId, watermark); replyMessage = botResponse.Text; } else { replyMessage = "Sorry, I don't understand."; } // Convert text to speech byte[] totalBytes; if (replyMessage.Contains("Music.Play")) { totalBytes = ((MemoryStream)SampleMusic.GetStream()).ToArray(); await handler.SendBinary(totalBytes); } else { try { var authorizationProvider = new CognitiveServicesAuthorizationProvider(CognitiveSubscriptionKey); string accessToken = await authorizationProvider.GetAuthorizationTokenAsync(); var cortana = new Synthesize(); totalBytes = await cortana.Speak(CancellationToken.None, new Synthesize.InputOptions() { RequestUri = new Uri(Constants.SpeechSynthesisUrl), Text = replyMessage, VoiceType = Gender.Female, Locale = "en-US", VoiceName = "Microsoft Server Speech Text to Speech Voice (en-US, ZiraRUS)", // Service can return audio in different output format. OutputFormat = AudioOutputFormat.Riff16Khz16BitMonoPcm, AuthorizationToken = "Bearer " + accessToken, }); // convert the audio format and send back to client WaveFormat target = new WaveFormat(8000, 16, 2); MemoryStream outStream = new MemoryStream(); using (WaveFormatConversionStream conversionStream = new WaveFormatConversionStream(target, new WaveFileReader(new MemoryStream(totalBytes)))) { WaveFileWriter.WriteWavFileToStream(outStream, conversionStream); outStream.Position = 0; } handler.SendBinary(outStream.ToArray()).Wait(); outStream.Dispose(); } catch (Exception e) { throw new DemoBotServiceException($"Convert text to speech failed: {e.Message}"); } } }