Merge pull request #229144 from eric-urban/eur/lid-updates

speech translation LID and code style

Author: JamesJBarnett

articles/cognitive-services/Speech-Service/includes/how-to/recognize-speech/cpp.md

@@ -20,7 +20,7 @@ Create a `SpeechConfig` instance by using your key and region. Create a Speech r
 using namespace std;
 using namespace Microsoft::CognitiveServices::Speech;
 
-auto config = SpeechConfig::FromSubscription("YourSpeechKey", "YourSpeechRegion");
+auto speechConfig = SpeechConfig::FromSubscription("YourSpeechKey", "YourSpeechRegion");
 ```
 
 You can initialize `SpeechConfig` in a few other ways:
@@ -40,10 +40,10 @@ To recognize speech by using your device microphone, create an [`AudioConfig`](/
 using namespace Microsoft::CognitiveServices::Speech::Audio;
 
 auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
-auto recognizer = SpeechRecognizer::FromConfig(config, audioConfig);
+auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);
 
 cout << "Speak into your microphone." << std::endl;
-auto result = recognizer->RecognizeOnceAsync().get();
+auto result = speechRecognizer->RecognizeOnceAsync().get();
 cout << "RECOGNIZED: Text=" << result->Text << std::endl;
 ```
 
@@ -56,10 +56,10 @@ If you want to recognize speech from an audio file instead of using a microphone
 ```cpp
 using namespace Microsoft::CognitiveServices::Speech::Audio;
 
-auto audioInput = AudioConfig::FromWavFileInput("YourAudioFile.wav");
-auto recognizer = SpeechRecognizer::FromConfig(config, audioInput);
+auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
+auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);
 
-auto result = recognizer->RecognizeOnceAsync().get();
+auto result = speechRecognizer->RecognizeOnceAsync().get();
 cout << "RECOGNIZED: Text=" << result->Text << std::endl;
 ```
 
@@ -72,7 +72,7 @@ The [Recognizer class](/cpp/cognitive-services/speech/speechrecognizer) for the
 Single-shot recognition asynchronously recognizes a single utterance. The end of a single utterance is determined by listening for silence at the end or until a maximum of 15 seconds of audio is processed. Here's an example of asynchronous single-shot recognition via [`RecognizeOnceAsync`](/cpp/cognitive-services/speech/speechrecognizer#recognizeonceasync):
 
 ```cpp
-auto result = recognizer->RecognizeOnceAsync().get();
+auto result = speechRecognizer->RecognizeOnceAsync().get();
 ```
 
 You need to write some code to handle the result. This sample evaluates [`result->Reason`](/cpp/cognitive-services/speech/recognitionresult#reason) and:
@@ -114,8 +114,8 @@ Continuous recognition is a bit more involved than single-shot recognition. It r
 Start by defining the input and initializing [`SpeechRecognizer`](/cpp/cognitive-services/speech/speechrecognizer):
 
 ```cpp
-auto audioInput = AudioConfig::FromWavFileInput("YourAudioFile.wav");
-auto recognizer = SpeechRecognizer::FromConfig(config, audioInput);
+auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
+auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);
 ```
 
 Next, create a variable to manage the state of speech recognition. Declare `promise<void>` because at the start of recognition, you can safely assume that it's not finished:
@@ -132,12 +132,12 @@ Next, subscribe to the events that [`SpeechRecognizer`](/cpp/cognitive-services/
 * [`Canceled`](/cpp/cognitive-services/speech/asyncrecognizer#canceled): Signal for events that contain canceled recognition results. These results indicate a recognition attempt that was canceled as a result or a direct cancellation request. Alternatively, they indicate a transport or protocol failure.
 
 ```cpp
-recognizer->Recognizing.Connect([](const SpeechRecognitionEventArgs& e)
+speechRecognizer->Recognizing.Connect([](const SpeechRecognitionEventArgs& e)
     {
         cout << "Recognizing:" << e.Result->Text << std::endl;
     });
 
-recognizer->Recognized.Connect([](const SpeechRecognitionEventArgs& e)
+speechRecognizer->Recognized.Connect([](const SpeechRecognitionEventArgs& e)
     {
         if (e.Result->Reason == ResultReason::RecognizedSpeech)
         {
@@ -150,7 +150,7 @@ recognizer->Recognized.Connect([](const SpeechRecognitionEventArgs& e)
         }
     });
 
-recognizer->Canceled.Connect([&recognitionEnd](const SpeechRecognitionCanceledEventArgs& e)
+speechRecognizer->Canceled.Connect([&recognitionEnd](const SpeechRecognitionCanceledEventArgs& e)
     {
         cout << "CANCELED: Reason=" << (int)e.Reason << std::endl;
         if (e.Reason == CancellationReason::Error)
@@ -163,7 +163,7 @@ recognizer->Canceled.Connect([&recognitionEnd](const SpeechRecognitionCanceledEv
         }
     });
 
-recognizer->SessionStopped.Connect([&recognitionEnd](const SessionEventArgs& e)
+speechRecognizer->SessionStopped.Connect([&recognitionEnd](const SessionEventArgs& e)
     {
         cout << "Session stopped.";
         recognitionEnd.set_value(); // Notify to stop recognition.
@@ -174,25 +174,31 @@ With everything set up, call [`StopContinuousRecognitionAsync`](/cpp/cognitive-s
 
 ```cpp
 // Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
-recognizer->StartContinuousRecognitionAsync().get();
+speechRecognizer->StartContinuousRecognitionAsync().get();
 
 // Waits for recognition end.
 recognitionEnd.get_future().get();
 
 // Stops recognition.
-recognizer->StopContinuousRecognitionAsync().get();
+speechRecognizer->StopContinuousRecognitionAsync().get();
 ```
 
 ## Change the source language
 
 A common task for speech recognition is specifying the input (or source) language. The following example shows how you would change the input language to German. In your code, find your [`SpeechConfig`](/cpp/cognitive-services/speech/speechconfig) instance and add this line directly below it:
 
 ```cpp
-config->SetSpeechRecognitionLanguage("de-DE");
+speechConfig->SetSpeechRecognitionLanguage("de-DE");
 ```
 
 [`SetSpeechRecognitionLanguage`](/cpp/cognitive-services/speech/speechconfig#setspeechrecognitionlanguage) is a parameter that takes a string as an argument. Refer to the [list of supported speech-to-text locales](../../../language-support.md?tabs=stt).
 
+## Language identification
+
+You can use [language identification](../../../language-identification.md?pivots=programming-language-cpp#speech-to-text) with Speech-to-text recognition when you need to identify the language in an audio source and then transcribe it to text.
+
+For a complete code sample, see [language identification](../../../language-identification.md?pivots=programming-language-cpp#speech-to-text).
+
 ## Use a custom endpoint
 
 With [Custom Speech](../../../custom-speech-overview.md), you can upload your own data, test and train a custom model, compare accuracy between models, and deploy a model to a custom endpoint. The following example shows how to set a custom endpoint.

articles/cognitive-services/Speech-Service/includes/how-to/recognize-speech/csharp.md

@@ -58,10 +58,10 @@ class Program
     async static Task FromMic(SpeechConfig speechConfig)
     {
         using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
-        using var recognizer = new SpeechRecognizer(speechConfig, audioConfig);
+        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
 
         Console.WriteLine("Speak into your microphone.");
-        var result = await recognizer.RecognizeOnceAsync();
+        var result = await speechRecognizer.RecognizeOnceAsync();
         Console.WriteLine($"RECOGNIZED: Text={result.Text}");
     }
 
@@ -91,9 +91,9 @@ class Program
     async static Task FromFile(SpeechConfig speechConfig)
     {
         using var audioConfig = AudioConfig.FromWavFileInput("PathToFile.wav");
-        using var recognizer = new SpeechRecognizer(speechConfig, audioConfig);
+        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
 
-        var result = await recognizer.RecognizeOnceAsync();
+        var result = await speechRecognizer.RecognizeOnceAsync();
         Console.WriteLine($"RECOGNIZED: Text={result.Text}");
     }
 
@@ -125,18 +125,18 @@ class Program
     async static Task FromStream(SpeechConfig speechConfig)
     {
         var reader = new BinaryReader(File.OpenRead("PathToFile.wav"));
-        using var audioInputStream = AudioInputStream.CreatePushStream();
-        using var audioConfig = AudioConfig.FromStreamInput(audioInputStream);
-        using var recognizer = new SpeechRecognizer(speechConfig, audioConfig);
+        using var audioConfigStream = AudioInputStream.CreatePushStream();
+        using var audioConfig = AudioConfig.FromStreamInput(audioConfigStream);
+        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
 
         byte[] readBytes;
         do
         {
             readBytes = reader.ReadBytes(1024);
-            audioInputStream.Write(readBytes, readBytes.Length);
+            audioConfigStream.Write(readBytes, readBytes.Length);
         } while (readBytes.Length > 0);
 
-        var result = await recognizer.RecognizeOnceAsync();
+        var result = await speechRecognizer.RecognizeOnceAsync();
         Console.WriteLine($"RECOGNIZED: Text={result.Text}");
     }
 
@@ -185,13 +185,13 @@ switch (result.Reason)
 
 The previous examples use single-shot recognition, which recognizes a single utterance. The end of a single utterance is determined by listening for silence at the end or until a maximum of 15 seconds of audio is processed.
 
-In contrast, you use continuous recognition when you want to control when to stop recognizing. It requires you to subscribe to the `Recognizing`, `Recognized`, and `Canceled` events to get the recognition results. To stop recognition, you must call [`StopContinuousRecognitionAsync`](/dotnet/api/microsoft.cognitiveservices.speech.speechrecognizer.stopcontinuousrecognitionasync). Here's an example of how continuous recognition is performed on an audio input file.
+In contrast, you use continuous recognition when you want to control when to stop recognizing. It requires you to subscribe to the `Recognizing`, `Recognized`, and `Canceled` events to get the recognition results. To stop recognition, you must call [`StopContinuousRecognitionAsync`](/dotnet/api/microsoft.cognitiveservices.speech.speechspeechRecognizer.stopcontinuousrecognitionasync). Here's an example of how continuous recognition is performed on an audio input file.
 
 Start by defining the input and initializing [`SpeechRecognizer`](/dotnet/api/microsoft.cognitiveservices.speech.speechrecognizer):
 
 ```csharp
 using var audioConfig = AudioConfig.FromWavFileInput("YourAudioFile.wav");
-using var recognizer = new SpeechRecognizer(speechConfig, audioConfig);
+using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
 ```
 
 Then create a `TaskCompletionSource<int>` instance to manage the state of speech recognition:
@@ -202,18 +202,18 @@ var stopRecognition = new TaskCompletionSource<int>();
 
 Next, subscribe to the events that `SpeechRecognizer` sends:
 
-* [`Recognizing`](/dotnet/api/microsoft.cognitiveservices.speech.speechrecognizer.recognizing): Signal for events that contain intermediate recognition results.
-* [`Recognized`](/dotnet/api/microsoft.cognitiveservices.speech.speechrecognizer.recognized): Signal for events that contain final recognition results, which indicate a successful recognition attempt.
-* [`SessionStopped`](/dotnet/api/microsoft.cognitiveservices.speech.recognizer.sessionstopped): Signal for events that indicate the end of a recognition session (operation).
-* [`Canceled`](/dotnet/api/microsoft.cognitiveservices.speech.speechrecognizer.canceled): Signal for events that contain canceled recognition results. These results indicate a recognition attempt that was canceled as a result or a direct cancellation request. Alternatively, they indicate a transport or protocol failure.
+* [`Recognizing`](/dotnet/api/microsoft.cognitiveservices.speech.speechspeechRecognizer.recognizing): Signal for events that contain intermediate recognition results.
+* [`Recognized`](/dotnet/api/microsoft.cognitiveservices.speech.speechspeechRecognizer.recognized): Signal for events that contain final recognition results, which indicate a successful recognition attempt.
+* [`SessionStopped`](/dotnet/api/microsoft.cognitiveservices.speech.speechRecognizer.sessionstopped): Signal for events that indicate the end of a recognition session (operation).
+* [`Canceled`](/dotnet/api/microsoft.cognitiveservices.speech.speechspeechRecognizer.canceled): Signal for events that contain canceled recognition results. These results indicate a recognition attempt that was canceled as a result or a direct cancellation request. Alternatively, they indicate a transport or protocol failure.
 
 ```csharp
-recognizer.Recognizing += (s, e) =>
+speechRecognizer.Recognizing += (s, e) =>
 {
     Console.WriteLine($"RECOGNIZING: Text={e.Result.Text}");
 };
 
-recognizer.Recognized += (s, e) =>
+speechRecognizer.Recognized += (s, e) =>
 {
     if (e.Result.Reason == ResultReason.RecognizedSpeech)
     {
@@ -225,7 +225,7 @@ recognizer.Recognized += (s, e) =>
     }
 };
 
-recognizer.Canceled += (s, e) =>
+speechRecognizer.Canceled += (s, e) =>
 {
     Console.WriteLine($"CANCELED: Reason={e.Reason}");
 
@@ -239,7 +239,7 @@ recognizer.Canceled += (s, e) =>
     stopRecognition.TrySetResult(0);
 };
 
-recognizer.SessionStopped += (s, e) =>
+speechRecognizer.SessionStopped += (s, e) =>
 {
     Console.WriteLine("\n    Session stopped event.");
     stopRecognition.TrySetResult(0);
@@ -249,13 +249,13 @@ recognizer.SessionStopped += (s, e) =>
 With everything set up, call `StartContinuousRecognitionAsync` to start recognizing:
 
 ```csharp
-await recognizer.StartContinuousRecognitionAsync();
+await speechRecognizer.StartContinuousRecognitionAsync();
 
 // Waits for completion. Use Task.WaitAny to keep the task rooted.
 Task.WaitAny(new[] { stopRecognition.Task });
 
 // Make the following call at some point to stop recognition:
-// await recognizer.StopContinuousRecognitionAsync();
+// await speechRecognizer.StopContinuousRecognitionAsync();
 ```
 
 ## Change the source language
@@ -268,6 +268,11 @@ speechConfig.SpeechRecognitionLanguage = "it-IT";
 
 The [`SpeechRecognitionLanguage`](/dotnet/api/microsoft.cognitiveservices.speech.speechconfig.speechrecognitionlanguage) property expects a language-locale format string. Refer to the [list of supported speech-to-text locales](../../../language-support.md?tabs=stt).
 
+## Language identification
+
+You can use [language identification](../../../language-identification.md?pivots=programming-language-csharp#speech-to-text) with Speech-to-text recognition when you need to identify the language in an audio source and then transcribe it to text.
+
+For a complete code sample, see [language identification](../../../language-identification.md?pivots=programming-language-csharp#speech-to-text).
 
 ## Use a custom endpoint