Introduction
The purpose of this article is it to give you a small insight of the capabilities of the System.Speech
assembly.
In detail, the usage of the SpeechRecognitionEngine
class. The MSDN documentation of the class
can be found here.
Background
I read several articles about how to use Text to Speech, but as I wanted to find out how to do it the opposite way,
I realized that there is a lack of easily understandable articles
covering this theme, so I decided to write a very basic one on my own and share my experiences with you.
The Solution
So now let's start. First of all you need to reference the System.Speech
assembly in your application located in the GAC.
This is the only reference needed containing the following namespaces and its classes. The System.Speech.Recognition
namespace
contains the Windows Desktop Speech technology types for implementing speech recognition.
System.Speech.AudioFormat
System.Speech.Recognition
System.Speech.Recognition.SrgsGrammar
System.Speech.Synthesis
System.Speech.Synthesis.TtsEngine
Before you can use SpeechRecognitionEngine
, you have to set up several properties and invoke some methods: in this case
I guess, code sometimes says more than words ...
SpeechRecognitionEngine speechRecognitionEngine = null;
speechRecognitionEngine = createSpeechEngine("de-DE");
speechRecognitionEngine.AudioLevelUpdated +=
new EventHandler<AudioLevelUpdatedEventArgs>(engine_AudioLevelUpdated);
speechRecognitionEngine.SpeechRecognized +=
new EventHandler<SpeechRecognizedEventArgs>(engine_SpeechRecognized);
loadGrammarAndCommands();
speechRecognitionEngine.SetInputToDefaultAudioDevice();
speechRecognitionEngine.RecognizeAsync(RecognizeMode.Multiple);
In detail now, the function createSpeechEngine(string preferredCulture)
. The standard constructor and its overloads are the following:
SpeechRecognitionEngine()
: Initializes a new instance using the default speech recognizer for the system.
SpeechRecognitionEngine(CultureInfo)
: Initializes a new instance using the default speech recognizer for a specified locale.
SpeechRecognitionEngine(RecognizerInfo)
: Initializes a new instance using the information in a RecognizerInfo
object to specify the recognizer to use.
SpeechRecognitionEngine(String)
: Initializes a new instance of the class with a string parameter that specifies the name of the recognizer to use.
The reason why I was creating a custom function for instantiating the class is that
I wanted to add the possibility to choose the language
that the engine is using. If the desired language is not installed, then the default language (Windows Desktop Language) is used.
Preventing an exception while choosing a not installed package. Hint: You can install further language packs to choose a different
CultureInfo
that is used by the SpeechRecognitionEnginge
but as far as I know, it is only supported on Win7 Ultimate/Enterprise.
private SpeechRecognitionEngine createSpeechEngine(string preferredCulture)
{
foreach (RecognizerInfo config in SpeechRecognitionEngine.InstalledRecognizers())
{
if (config.Culture.ToString() == preferredCulture)
{
speechRecognitionEngine = new SpeechRecognitionEngine(config);
break;
}
}
if (speechRecognitionEngine == null)
{
MessageBox.Show("The desired culture is not installed " +
"on this machine, the speech-engine will continue using "
+ SpeechRecognitionEngine.InstalledRecognizers()[0].Culture.ToString() +
" as the default culture.", "Culture " + preferredCulture + " not found!");
speechRecognitionEngine = new SpeechRecognitionEngine();
}
return speechRecognitionEngine;
}
The next step is it to set up the used Grammar
that is loaded by the SpeechRecognitionEngine
.
In our case, we create a custom text file that contains key-value pairs of texts wrapped in the custom class SpeechToText.Word
because I wanted to extend the
usability of the program and give you a little showcase on what is possible with SAPI. That is interesting because in doing so,
we are able to associate texts or even commands to a recognized word. Here is the wrapper class SpeechToText.Word
.
namespace SpeechToText
{
public class Word
{
public Word() { }
public string Text { get; set; } public string AttachedText { get; set; } public bool IsShellCommand { get; set; } }
}
Here is the method to set up the Choices
used by the Grammar
. In the
foreach
loop, we
create and insert the Word
classes and store them for later usage in a lookup List<Word>
. Afterwards we insert the parsed words
into the Choices
class and finally build the Grammar
by using a GrammarBuilder
and load it synchronously
with the SpeechRecognitionEngine
. You could also simply add
string
s to the choices class by hand or load a predefined XML-file.
Now our engine is ready to recognize the predefined words.
private void loadGrammarAndCommands()
{
try
{
Choices texts = new Choices();
string[] lines = File.ReadAllLines(Environment.CurrentDirectory + "\\example.txt");
foreach (string line in lines)
{
if (line.StartsWith("--") || line == String.Empty) continue;
var parts = line.Split(new char[] { '|' });
words.Add(new Word() { Text = parts[0], AttachedText = parts[1],
IsShellCommand = (parts[2] == "true") });
texts.Add(parts[0]);
}
Grammar wordsList = new Grammar(new GrammarBuilder(texts));
speechRecognitionEngine.LoadGrammar(wordsList);
}
catch (Exception ex)
{
throw ex;
}
}
To start the SpeechRecognitionEngine
, we call SpeechRecognitionEngine.StartRecognizeAsync(RecognizeMode.Multiple)
.
This means that the recognizer continues performing asynchronous recognition operations until the RecognizeAsyncCancel()
or RecognizeAsyncStop()
method is called. To retrieve the result of an asynchronous recognition operation, attach an event handler to the recognizer's
SpeechRecognized
event.
The recognizer raises this event whenever it successfully completes a synchronous or asynchronous recognition operation.
speechRecognitionEngine.SpeechRecognized +=
new EventHandler<SpeechRecognizedEventArgs>(engine_SpeechRecognized);
speechRecognitionEngine.RecognizeAsync(RecognizeMode.Multiple);
void engine_SpeechRecognized(object sender, SpeechRecognizedEventArgs e)
{
txtSpoken.Text += "\r" + getKnownTextOrExecute(e.Result.Text);
scvText.ScrollToEnd();
}
And here comes the gimmick of this application, when the engine recognizes one of our predefined words, we decide whether to return the associated text, or to
execute a shell command. This is done in the following function:
private string getKnownTextOrExecute(string command)
{
try
{ var cmd = words.Where(c => c.Text == command).First();
if (cmd.IsShellCommand)
{
Process proc = new Process();
proc.EnableRaisingEvents = false;
proc.StartInfo.FileName = cmd.AttachedText;
proc.Start();
return "you just started : " + cmd.AttachedText;
}
else
{
return cmd.AttachedText;
}
}
catch (Exception)
{
return command;
}
}
That is it! There are plenty of other possibilities to use the SAPI for, maybe a Visual Studio
plug-in for coding? Let me know what ideas you guys have! I hope you enjoyed my first article.
History
Version 1.0.0.0 release.