private void SetupTranscriptionAndTranslationService()
{
try
{
var lCognitiveKey = _settings.AzureCognitiveKey;
var lCognitiveRegion = _settings.AzureCognitiveRegion;
_eventPublisher.Publish("MySTT Setup", $"Got region: {lCognitiveRegion}, key starting from: {lCognitiveKey??lCognitiveKey.Substring(0, lCognitiveKey.Length /2)}");
this.mTransSpeechConfig = SpeechTranslationConfig.FromSubscription(lCognitiveKey, lCognitiveRegion);
var fromLanguage = "en-US";
var toLanguages = new List <string> {
"el-GR"
};
//var toLanguages = new List<string> { "ru-RU" };
this.mTransSpeechConfig.SpeechRecognitionLanguage = fromLanguage;
toLanguages.ForEach(this.mTransSpeechConfig.AddTargetLanguage);
this.mInputStream = AudioInputStream.CreatePushStream(AudioStreamFormat.GetWaveFormatPCM(SAMPLESPERSECOND, BITSPERSAMPLE, NUMBEROFCHANNELS));
this.mAudioConfig = AudioConfig.FromStreamInput(this.mInputStream);
this.mTranslationRecognizer = new TranslationRecognizer(this.mTransSpeechConfig, this.mAudioConfig);
this.mTranslationRecognizer.Recognizing += this.MSpeechRecognizer_Recognizing;
this.mTranslationRecognizer.Recognized += this.MSpeechRecognizer_Recognized;
this.mTranslationRecognizer.SpeechEndDetected += this.MSpeechRecognizer_SpeechEndDetected;
this.StartRecognisionIfNeeded();
}
catch (Exception ex)
{
_eventPublisher.Publish("MySTT Setup - Failed", $"Failed to initialize: {ex.Message}");
}
}
private async void StopRecognition()
{
if (!isRecognitionStarted)
{
return;
}
Debug.Log("stop recognition");
translatingMessage = "";
translatedMessage = "";
await recognizer.StopContinuousRecognitionAsync().ConfigureAwait(false);
recognizer.Canceled -= CanceledHandler;
recognizer.SessionStarted -= SessionStartedHandler;
recognizer.SessionStopped -= SessionStoppedHandler;
recognizer.SpeechStartDetected -= SpeechStartDetectedHandler;
recognizer.SpeechEndDetected -= SpeechEndDetectedHandler;
recognizer.Recognizing -= RecognizingHandler;
recognizer.Recognized -= RecognizedHandler;
recognizer.Dispose();
recognizer = null;
isRecognitionStarted = false;
isRecognitionStateChanged = true;
}
public static async Task <String> TranslationContinuousRecognitionAsync()
{
var config = SpeechTranslationConfig.FromSubscription("a8c500c9ef9f421e977486a17f0adcca", "westeurope");
string fromLanguage = "pl-PL";
config.SpeechRecognitionLanguage = fromLanguage;
config.AddTargetLanguage("pl");
string result = "";
// Sets voice name of synthesis output.
const string PolishVoice = "pl-PL";
config.VoiceName = PolishVoice;
// Creates a translation recognizer using microphone as audio input.
using (var recognizer = new TranslationRecognizer(config))
{
// Subscribes to events.
recognizer.Recognized += async(s, e) =>
{
if (e.Result.Reason == ResultReason.TranslatedSpeech)
{
await recognizer.StopContinuousRecognitionAsync();
result = e.Result.Text;
}
};
return(result);
}
}
public async Task StartSpeechRecognitionAsync()
{
SpeechTranslationConfig config = GetRecognizerConfig();
if (config == null)
{
return;
}
ResetState();
DisposeRecognizer();
DeviceInformation microphoneInput = await Util.GetDeviceInformation(DeviceClass.AudioCapture, SettingsHelper.Instance.MicrophoneName);
using (AudioConfig audioConfig = AudioConfig.FromMicrophoneInput(microphoneInput.Id))
{
translationRecognizer = audioConfig != null ? new TranslationRecognizer(config, audioConfig) : new TranslationRecognizer(config);
translationRecognizer.Recognizing += OnTranslateRecognizing;
translationRecognizer.Recognized += OnTranslateRecognized;
translationRecognizer.Canceled += OnTranslateCanceled;
translationRecognizer.SessionStarted += (s, e) =>
{
recognizeCancellationTokenSource = new CancellationTokenSource();
};
await translationRecognizer.StartContinuousRecognitionAsync();
}
}
void Start()
{
Debug.Log("Start");
isRecognitionStarted = false;
isRecognitionStateChanged = false;
recognizer = null;
ui = GameObject.Find("Canvas");
uiCanvas = ui.GetComponent <Canvas>();
uiScaler = ui.GetComponent <CanvasScaler>();
isUIVisible = true;
HideUI();
apiKeyInputField = GameObject.Find("ApiKeyInputField").GetComponent <InputField>();
apiRegionInputField = GameObject.Find("ApiRegionInputField").GetComponent <InputField>();
modeList = GameObject.Find("ModeList").GetComponent <Dropdown>();
modeList.onValueChanged.AddListener(ModeListValueChangeHandler);
startStopButton = GameObject.Find("StartStopButton").GetComponent <Button>();
startStopButton.onClick.AddListener(StartStopButtonClickHandler);
startStopButtonText = GameObject.Find("StartStopButtonText").GetComponent <Text>();
applyStartStopButtonLabel();
subtitles = GameObject.Find("Subtitles");
subtitlesText = subtitles.GetComponent <TextMeshPro>();
subtitlesText.text = "";
float gray = 0.8f;
translatingMessageColor = new Color(gray, gray, gray, 0.5f);
translatedMessageColor = new Color(1.0f, 1.0f, 1.0f, 1.0f);
}
/// <summary>
/// Stops the recognition on the speech recognizer or translator as applicable.
/// Important: Unhook all events & clean-up resources.
/// </summary>
public async void StopRecognition()
{
if (recognizer != null)
{
await recognizer.StopContinuousRecognitionAsync().ConfigureAwait(false);
recognizer.Recognizing -= RecognizingHandler;
recognizer.Recognized -= RecognizedHandler;
recognizer.SpeechStartDetected -= SpeechStartDetectedHandler;
recognizer.SpeechEndDetected -= SpeechEndDetectedHandler;
recognizer.Canceled -= CanceledHandler;
recognizer.SessionStarted -= SessionStartedHandler;
recognizer.SessionStopped -= SessionStoppedHandler;
recognizer.Dispose();
recognizer = null;
recognizedString = "Speech Recognizer is now stopped.";
Debug.Log("Speech Recognizer is now stopped.");
}
if (translator != null)
{
await translator.StopContinuousRecognitionAsync().ConfigureAwait(false);
translator.Recognizing -= RecognizingTranslationHandler;
translator.Recognized -= RecognizedTranslationHandler;
translator.SpeechStartDetected -= SpeechStartDetectedHandler;
translator.SpeechEndDetected -= SpeechEndDetectedHandler;
translator.Canceled -= CanceledTranslationHandler;
translator.SessionStarted -= SessionStartedHandler;
translator.SessionStopped -= SessionStoppedHandler;
translator.Dispose();
translator = null;
recognizedString = "Speech Translator is now stopped.";
Debug.Log("Speech Translator is now stopped.");
}
}
/// <summary>
/// Initializes the factory object with subscription key and region
/// Initializes the recognizer object with a TranslationRecognizer
/// Subscribes the recognizer to recognition Event Handlers
/// If recognition is running, starts a thread which stops the recognition
/// </summary>
private void CreateRecognizer()
{
string region = "eastasia";
string fromLanguage = "en-US";
//var toLanguages = new List<string>() { "zh", "de" };
var toLanguages = new List <string>()
{
"ja"
};
// var voiceChinese = "zh-CN-Yaoyao";
var voiceChinese = "ja-JP-Ayumi";
string sub_key = "7620810559eb4d1c96f770c5ee019bd3";
//string sub_key = "91ad01e1da954931955dc87b6fb71c0c";
//this.factory = SpeechFactory.FromSubscription(SubscriptionKey, region);
this.factory = SpeechFactory.FromSubscription(sub_key, region);
this.recognizer = this.factory.CreateTranslationRecognizer(fromLanguage, toLanguages, voiceChinese);
this.recognizer.IntermediateResultReceived += this.OnPartialResponseReceivedHandler;
this.recognizer.FinalResultReceived += this.OnFinalResponse;
this.recognizer.SynthesisResultReceived += this.OnSynthesis;
this.recognizer.RecognitionErrorRaised += this.OnError;
}
public static async Task TranslateSpeechToText()
{
// Creates an instance of a speech translation config with specified subscription key and service region.
// Replace with your own subscription key and service region (e.g., "westus").
var config = SpeechTranslationConfig.FromSubscription("311b76d8841344b6a277dbd8401611dc", "westus");
// Sets source and target languages.
// Replace with the languages of your choice, from list found here: https://aka.ms/speech/sttt-languages
string fromLanguage = "en-US";
config.SpeechRecognitionLanguage = fromLanguage;
config.AddTargetLanguage("de");
config.AddTargetLanguage("fr");
// Creates a translation recognizer using the default microphone audio input device.
using (var recognizer = new TranslationRecognizer(config))
{
// Starts translation, and returns after a single utterance is recognized. 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. The task returns the recognized text as well as the translation.
// Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
// shot recognition like command or query.
// For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
Console.WriteLine("Say something...");
var result = await recognizer.RecognizeOnceAsync();
// Checks result.
if (result.Reason == ResultReason.TranslatedSpeech)
{
Console.WriteLine($"RECOGNIZED '{fromLanguage}': {result.Text}");
foreach (var element in result.Translations)
{
Console.WriteLine($"TRANSLATED into '{element.Key}': {element.Value}");
}
}
else if (result.Reason == ResultReason.RecognizedSpeech)
{
Console.WriteLine($"RECOGNIZED '{fromLanguage}': {result.Text} (text could not be translated)");
}
else if (result.Reason == ResultReason.NoMatch)
{
Console.WriteLine($"NOMATCH: Speech could not be recognized.");
}
else if (result.Reason == ResultReason.Canceled)
{
var cancellation = CancellationDetails.FromResult(result);
Console.WriteLine($"CANCELED: Reason={cancellation.Reason}");
if (cancellation.Reason == CancellationReason.Error)
{
Console.WriteLine($"CANCELED: ErrorCode={cancellation.ErrorCode}");
Console.WriteLine($"CANCELED: ErrorDetails={cancellation.ErrorDetails}");
Console.WriteLine($"CANCELED: Did you update the subscription info?");
}
}
}
}
/// <summary>
/// Initializes the factory object with subscription key and region
/// Initializes the recognizer object with a TranslationRecognizer
/// Subscribes the recognizer to recognition Event Handlers
/// If recognition is running, starts a thread which stops the recognition
/// </summary>
private void CreateRecognizer()
{
this.factory = SpeechFactory.FromSubscription(SubscriptionKey, Region);
this.recognizer = this.factory.CreateTranslationRecognizer(FromLanguage, ToLanguages, voice);
this.recognizer.IntermediateResultReceived += this.OnPartialResponseReceivedHandler;
this.recognizer.FinalResultReceived += this.OnFinalResponse;
this.recognizer.SynthesisResultReceived += this.OnSynthesis;
this.recognizer.RecognitionErrorRaised += this.OnError;
}
private void DisposeRecognizer()
{
if (translationRecognizer != null)
{
translationRecognizer.Recognizing -= OnTranslateRecognizing;
translationRecognizer.Recognized -= OnTranslateRecognized;
translationRecognizer.Canceled -= OnTranslateCanceled;
translationRecognizer = null;
}
}
public void Dispose()
{
if (recognized != null)
{
recognized.Recognizing -= OnSpeechRecognizing;
recognized.SessionStarted -= OnSessionStarted;
recognized.SessionStopped -= OnSessionStopped;
recognized.Dispose();
recognized = null;
}
}
private async Task StartSpeechTranscriptionEngine(string recognitionLanguage, string targetLanguage)
{
_translationConfig.SpeechRecognitionLanguage = recognitionLanguage;
_translationConfig.AddTargetLanguage(targetLanguage);
_speechConfig.SpeechRecognitionLanguage = targetLanguage;
_speechConfig.SpeechSynthesisLanguage = targetLanguage;
_synthesizer = new SpeechSynthesizer(_speechConfig, _output);
_recognizer = new TranslationRecognizer(_translationConfig, _audioInput);
_recognizer.Recognized += RecognizerRecognized;
await _recognizer.StartContinuousRecognitionAsync();
}
public async Task <ActionResult> translateAsync()
{
string fromLanguage = "en-US";
const string GermanVoice = "Microsoft Server Speech Text to Speech Voice (de-DE, Hedda)";
var config = SpeechTranslationConfig.FromSubscription("ae9492aae8044a4c888a45a45e957d83", "westus");
config.SpeechRecognitionLanguage = fromLanguage;
config.VoiceName = GermanVoice;
config.AddTargetLanguage("de");
using (var recognizer = new TranslationRecognizer(config))
{
recognizer.Recognizing += (s, e) =>
{
foreach (var element in e.Result.Translations)
{
ViewBag.message = element.Value;
}
};
recognizer.Recognized += (s, e) =>
{
if (e.Result.Reason == ResultReason.TranslatedSpeech)
{
foreach (var element in e.Result.Translations)
{
ViewBag.message = element.Value;
}
}
else if (e.Result.Reason == ResultReason.RecognizedSpeech)
{
foreach (var element in e.Result.Translations)
{
ViewBag.message = element.Value;
}
}
else if (e.Result.Reason == ResultReason.NoMatch)
{
}
};
await recognizer.RecognizeOnceAsync();
return(View("Index"));
}
}
protected async Task StopRecognition()
{
if (speechRecognizer != null)
{
await speechRecognizer.StopContinuousRecognitionAsync();
}
if (translationRecognizer != null)
{
await translationRecognizer.StopContinuousRecognitionAsync();
}
speechRecognizer = null;
translationRecognizer = null;
}
/// <summary>
/// Initializes the config object with subscription key and region
/// Initializes the recognizer object with a TranslationRecognizer
/// Subscribes the recognizer to recognition Event Handlers
/// If recognition is running, starts a thread which stops the recognition
/// </summary>
private void CreateRecognizer()
{
this.config = SpeechTranslationConfig.FromSubscription(SubscriptionKey, Region);
this.config.SpeechRecognitionLanguage = FromLanguage;
this.config.VoiceName = voice;
ToLanguages.ForEach(l => this.config.AddTargetLanguage(l));
this.recognizer = new TranslationRecognizer(this.config);
this.recognizer.Recognizing += this.OnRecognizingEventHandler;
this.recognizer.Recognized += this.OnRecognizedEventHandler;
this.recognizer.Synthesizing += this.OnSynthesizingEventHandler;
this.recognizer.Canceled += this.OnCanceledEventHandler;
}
void Start()
{
if (outputText == null)
{
UnityEngine.Debug.LogError("outputText property is null! Assign a UI Text element to it.");
}
else if (recoButton == null)
{
_message = "recoButton property is null! Assign a UI Button to it.";
UnityEngine.Debug.LogError(_message);
}
else
{
// Continue with normal initialization, Text and Button objects are present.
#if PLATFORM_ANDROID
// Request to use the microphone, cf.
// https://docs.unity3d.com/Manual/android-RequestingPermissions.html
message = "Waiting for mic permission";
if (!Permission.HasUserAuthorizedPermission(Permission.Microphone))
{
Permission.RequestUserPermission(Permission.Microphone);
}
#elif PLATFORM_IOS
if (!Application.HasUserAuthorization(UserAuthorization.Microphone))
{
Application.RequestUserAuthorization(UserAuthorization.Microphone);
}
#else
_micPermissionGranted = true;
_message = "Click button to recognize speech";
#endif
_config = SpeechTranslationConfig.FromSubscription(SubscriptionKey, SubscriptionRegion);
_config.SpeechRecognitionLanguage = "es-US";
_config.AddTargetLanguage("en-US");
_pushStream = AudioInputStream.CreatePushStream();
_audioInput = AudioConfig.FromStreamInput(_pushStream);
_recognizer = new TranslationRecognizer(_config, _audioInput);
_recognizer.Recognizing += RecognizingHandler;
_recognizer.Recognized += RecognizedHandler;
_recognizer.Canceled += CanceledHandler;
foreach (var device in Microphone.devices)
{
Debug.Log("DeviceName: " + device);
}
_audioSource = GameObject.Find("AudioSource").GetComponent <AudioSource>();
}
}
public void Dispose()
{
if (recognizer != null)
{
recognizer.Recognizing -= OnSpeechRecognizing;
recognizer.SessionStarted -= OnSessionStarted;
recognizer.SessionStopped -= OnSessionStopped;
recognizer.Dispose();
recognizer = null;
}
if (audioConfig != null)
{
audioConfig.Dispose();
audioConfig = null;
}
}
private void CreateRecognizer()
{
//Microsoft.CognitiveServices.Speech.Internal.carbon_csharp a = new car();
this.config = SpeechTranslationConfig.FromSubscription(SubscriptionKey, Region);
this.config.SpeechRecognitionLanguage = FromLanguage;
this.config.VoiceName = voice;
ToLanguages.ForEach(l => this.config.AddTargetLanguage(l));
this.recognizer = new TranslationRecognizer(this.config);
this.recognizer.Recognizing += this.OnRecognizingEventHandler;
this.recognizer.Recognized += this.OnRecognizedEventHandler;
this.recognizer.Synthesizing += this.OnSynthesizingEventHandler;
this.recognizer.Canceled += this.OnCanceledEventHandler;
}
void ListenForSpeech()
{
try
{
translationReco = factory.CreateTranslationRecognizer("en-US", new List <string> {
"de"
}, "de-DE-Hedda");
translationReco.SynthesisResult += (s, e) =>
{
Log.Info("SpeechSDKDemo", $"Synthesis Result {e.Value.SynthesisStatus}");
if (e.Value.SynthesisStatus == SynthesisStatus.Success)
{
PlayWay(e.Value.GetAudio());
}
};
translationReco.FinalResult += (s, e) =>
{
Log.Info("SpeechSDKDemo", $"Final result {e.Value.Text}");
if (!string.IsNullOrWhiteSpace(e.Value.Text))
{
RunOnUiThread(() => FullOutput.Text += $"{ e.Value.Translations["de"]} ");
}
};
translationReco.IntermediateResult += (s, e) =>
{
Log.Info("SpeechSDKDemo", $"Translation intermediate result {e.Value.Text}");
if (!string.IsNullOrWhiteSpace(e.Value.Text))
{
RunOnUiThread(() => IntermediateOutput.Text = $"{e.Value.Text} - { e.Value.Translations["de"]} ");
}
};
translationReco.RecognitionError += (s, e) =>
{
Log.Info("SpeechSDKDemo", $"Error result {e.Value?.Name()}");
};
translationReco.StartContinuousRecognitionAsync();
}
catch (Exception ex)
{
Log.Error("SpeechSDKDemo", $"unexpected {ex.Message}");
}
}
public async Task CreateTranslationRecognizer()
{
if (recognized != null)
{
await recognized.StopContinuousRecognitionAsync();
await recognized.StopKeywordRecognitionAsync();
}
recognized = new TranslationRecognizer(speechConfiguration);
recognized.Recognizing += OnSpeechRecognizing;
recognized.SessionStarted += OnSessionStarted;
recognized.SessionStopped += OnSessionStopped;
recognized.Recognized += OnRecognized;
recognized.Synthesizing += OnSynthesizing;
recognized.Canceled += OnCanceled;
}
private void Init(string from, string to)
{
this.toLanguage = to;
Profile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.Low);
Profile.Audio = AudioEncodingProperties.CreatePcm(16000, 1, 16);
byte channels = 1;
byte bitsPerSample = 16;
uint samplesPerSecond = 16000; // or 8000
var audioFormat = AudioStreamFormat.GetWaveFormatPCM(samplesPerSecond, bitsPerSample, channels);
// Init Push Stream
pushStream = AudioInputStream.CreatePushStream(audioFormat);
if (from == to)
{
var config = SpeechConfig.FromSubscription(apiKey, region);
config.SpeechRecognitionLanguage = from;
speechRecognizer = new SpeechRecognizer(config, AudioConfig.FromStreamInput(pushStream));
speechRecognizer.Recognizing += RecognisingSpeechHandler;
speechRecognizer.Recognized += RecognisingSpeechHandler;
speechRecognizer.SessionStarted += (sender, args) => this.RecognisionStarted?.Invoke();
speechRecognizer.SessionStopped += (sender, args) => this.RecognisionStopped?.Invoke();
}
else
{
var config = SpeechTranslationConfig.FromSubscription(apiKey, region);
config.SpeechRecognitionLanguage = from;
config.AddTargetLanguage(to);
translationRecognizer = new TranslationRecognizer(config, AudioConfig.FromStreamInput(pushStream));
translationRecognizer.SessionStarted += (sender, args) => this.RecognisionStarted?.Invoke();
translationRecognizer.SessionStopped += (sender, args) => this.RecognisionStopped?.Invoke();
translationRecognizer.Recognizing += RecognisingTranslationHandler;
translationRecognizer.Recognized += RecognisingTranslationHandler;
}
}
public async void ButtonClick()
{
Debug.Log("Onclick fired");
var translationConfig = SpeechTranslationConfig.FromSubscription(SpeechServiceSubscriptionKey, SpeechServiceRegion);
translationConfig.SpeechRecognitionLanguage = "en-US";
translationConfig.AddTargetLanguage("fr");
using (var recognizer = new TranslationRecognizer(translationConfig))
{
Debug.Log("Creating recognizer");
lock (threadLocker)
{
waitingforReco = true;
}
var result = await recognizer.RecognizeOnceAsync().ConfigureAwait(false);
if (result.Reason == ResultReason.TranslatedSpeech)
{
recognizedString = result.Text;
Debug.Log("Text: " + recognizedString);
foreach (var element in result.Translations)
{
translatedString = element.Value;
}
}
else if (result.Reason == ResultReason.NoMatch)
{
recognizedString = "NOMATCH: Speech could not be recognized.";
}
else if (result.Reason == ResultReason.Canceled)
{
var cancellation = CancellationDetails.FromResult(result);
recognizedString = $"CANCELED: Reason={cancellation.Reason} ErrorDetails={cancellation.ErrorDetails}";
}
lock (threadLocker)
{
waitingforReco = false;
}
}
}
public void HandleOnSelectRecognitionMode(RecognitionMode recognitionMode)
{
if (recognitionMode == RecognitionMode.Tralation_Recognizer)
{
recognizedString = "Say something...";
translatedString = "";
BeginTranslating();
}
else
{
if (translator != null)
{
translator.StopContinuousRecognitionAsync();
}
translator = null;
recognizedString = "";
translatedString = "";
}
}
/// <summary>
/// Initializes the factory object with subscription key and region
/// Initializes the recognizer object with a TranslationRecognizer
/// Subscribes the recognizer to recognition Event Handlers
/// If recognition is running, starts a thread which stops the recognition
/// </summary>
private void CreateRecognizer()
{
string region = "westus";
string fromLanguage = "en-US";
var toLanguages = new List <string>()
{
"zh", "de"
};
var voiceChinese = "zh-CN-Yaoyao";
this.factory = SpeechFactory.FromSubscription(SubscriptionKey, region);
this.recognizer = this.factory.CreateTranslationRecognizer(fromLanguage, toLanguages, voiceChinese);
this.recognizer.IntermediateResultReceived += this.OnPartialResponseReceivedHandler;
this.recognizer.FinalResultReceived += this.OnFinalResponse;
this.recognizer.SynthesisResultReceived += this.OnSynthesis;
this.recognizer.RecognitionErrorRaised += this.OnError;
}
private async void StartRecognition()
{
if (isRecognitionStarted)
{
return;
}
Debug.Log("start recognition");
string fromLang;
string toLang;
if (modeList.value == 0)
{
fromLang = "ja-JP";
toLang = "en";
}
else
{
fromLang = "en-US";
toLang = "ja";
}
Debug.Log("mode : " + fromLang + " -> " + toLang);
var config = SpeechTranslationConfig.FromSubscription(apiKeyInputField.text, apiRegionInputField.text);
config.SpeechRecognitionLanguage = fromLang;
config.AddTargetLanguage(toLang);
recognizer = new TranslationRecognizer(config);
recognizer.Canceled += CanceledHandler;
recognizer.SessionStarted += SessionStartedHandler;
recognizer.SessionStopped += SessionStoppedHandler;
recognizer.SpeechStartDetected += SpeechStartDetectedHandler;
recognizer.SpeechEndDetected += SpeechEndDetectedHandler;
recognizer.Recognizing += RecognizingHandler;
recognizer.Recognized += RecognizedHandler;
await recognizer.StartContinuousRecognitionAsync().ConfigureAwait(false);
isRecognitionStarted = true;
isRecognitionStateChanged = true;
}
public async Task SpeechRecognitionFromFileAsync(StorageFile file)
{
SpeechTranslationConfig config = GetRecognizerConfig();
if (config == null)
{
return;
}
ResetState();
stopRecognitionTaskCompletionSource = new TaskCompletionSource <int>();
using (var audioInput = AudioConfig.FromWavFileInput(file.Path))
{
using (var recognizer = new TranslationRecognizer(config, audioInput))
{
recognizer.Recognizing += OnTranslateRecognizing;
recognizer.Recognized += OnTranslateRecognized;
recognizer.Canceled += OnTranslateCanceled;
recognizer.SessionStarted += (s, e) =>
{
recognizeCancellationTokenSource = new CancellationTokenSource();
};
recognizer.SessionStopped += (s, e) =>
{
if (recognizeCancellationTokenSource != null && recognizeCancellationTokenSource.Token.CanBeCanceled)
{
recognizeCancellationTokenSource.Cancel();
}
stopRecognitionTaskCompletionSource.TrySetResult(0);
};
// Starts continuous recognition.
await recognizer.StartContinuousRecognitionAsync().ConfigureAwait(false);
// Waits for completion.
await stopRecognitionTaskCompletionSource.Task.ConfigureAwait(false);
// Stops recognition.
await recognizer.StopContinuousRecognitionAsync().ConfigureAwait(false);
}
}
}
void CreateTranslationRecognizer()
{
if (translator == null)
{
SpeechTranslationConfig config = SpeechTranslationConfig.FromSubscription(lunarcomController.SpeechServiceAPIKey, lunarcomController.SpeechServiceRegion);
config.SpeechRecognitionLanguage = fromLanguage;
config.AddTargetLanguage(toLanguage);
translator = new TranslationRecognizer(config);
if (translator != null)
{
translator.Recognizing += HandleTranslatorRecognizing;
translator.Recognized += HandleTranslatorRecognized;
translator.Canceled += HandleTranslatorCanceled;
translator.SessionStarted += HandleTranslatorSessionStarted;
translator.SessionStopped += HandleTranslatorSessionStopped;
}
}
}
public async Task <List <LanguageModel> > TranslateToText(string _fromLanguage, List <string> _toLanguages)
{
// Creates an instance of a speech factory with specified
// subscription key and service region. Replace with your own subscription key
// and service region (e.g., "westus").
var factory = SpeechFactory.FromSubscription(this.key, this.azureServer);
List <LanguageModel> textAndTranslations = new List <LanguageModel>();
using (TranslationRecognizer trecognizer = factory.CreateTranslationRecognizer(_fromLanguage, _toLanguages))
{
var result = await trecognizer.RecognizeAsync();
if (result.RecognitionStatus != RecognitionStatus.Recognized)
{
if (result.RecognitionStatus == RecognitionStatus.Canceled)
{
textAndTranslations.Add(new LanguageModel("Error", "There was an error, reason:" + result.RecognitionFailureReason));
}
else
{
textAndTranslations.Add(new LanguageModel("Error", "No speech could be recognized.\n"));
}
}
else
{
if (result.TranslationStatus == TranslationStatus.Success)
{
textAndTranslations.Add(new LanguageModel(_fromLanguage, result.Text));
foreach (var element in result.Translations)
{
textAndTranslations.Add(new LanguageModel(element.Key, element.Value));
Console.WriteLine(element.Key);
}
}
}
}
return(textAndTranslations);
}
static async Task Translate(string targetLanguage)
{
string translation = "";
// Translate speech
string audioFile = "station.wav";
SoundPlayer wavPlayer = new SoundPlayer(audioFile);
// Play the audio synchronously, otherwise the translation will interrupt it
wavPlayer.PlaySync();
using AudioConfig audioConfig = AudioConfig.FromWavFileInput(audioFile);
using TranslationRecognizer translator = new TranslationRecognizer(translationConfig, audioConfig);
// Add an inline event handler to handle the Synthesizing event and output the audio to the current output device
translator.Synthesizing += (_, e) =>
{
var audio = e.Result.GetAudio();
if (audio.Length > 0)
{
// Output to a file using File.WriteAllBytes("YourAudioFile.wav", audio);
// Or place the data into a stream and play to the current output device
using (System.IO.MemoryStream ms = new System.IO.MemoryStream(audio))
{
// Construct the sound player
SoundPlayer player = new SoundPlayer(ms);
player.Play();
}
}
};
Console.WriteLine("Getting speech from file...");
TranslationRecognitionResult result = await translator.RecognizeOnceAsync();
Console.WriteLine($"Translating '{result.Text}'");
translation = result.Translations[targetLanguage];
Console.OutputEncoding = Encoding.UTF8;
Console.WriteLine(translation);
}
/// <summary>
/// Creates a class-level Translation Recognizer for a specific language using Azure credentials
/// and hooks-up lifecycle & recognition events. Translation can be enabled with one or more target
/// languages translated simultaneously
/// </summary>
void CreateTranslationRecognizer()
{
Debug.Log("Creating Translation Recognizer.");
recognizedString = "Initializing speech recognition with translation, please wait...";
if (translator == null)
{
SpeechTranslationConfig config = SpeechTranslationConfig.FromSubscription(SpeechServiceAPIKey, SpeechServiceRegion);
config.SpeechRecognitionLanguage = fromLanguage;
if (Languages1.captionText.text.Length > 0)
{
config.AddTargetLanguage(ExtractLanguageCode(Languages1.captionText.text));
}
if (Languages2.captionText.text.Length > 0)
{
config.AddTargetLanguage(ExtractLanguageCode(Languages2.captionText.text));
}
if (Languages3.captionText.text.Length > 0)
{
config.AddTargetLanguage(ExtractLanguageCode(Languages3.captionText.text));
}
translator = new TranslationRecognizer(config);
if (translator != null)
{
translator.Recognizing += RecognizingTranslationHandler;
translator.Recognized += RecognizedTranslationHandler;
translator.SpeechStartDetected += SpeechStartDetectedHandler;
translator.SpeechEndDetected += SpeechEndDetectedHandler;
translator.Canceled += CanceledTranslationHandler;
translator.SessionStarted += SessionStartedHandler;
translator.SessionStopped += SessionStoppedHandler;
}
}
Debug.Log("CreateTranslationRecognizer exit");
}
