It looks like I'll be speaking at
the Day of .NET in Ann Arbor, MI. And in preparation for that event, the
Ann Arbor Computer Society is having a night of
Grok Talks on .NET topics, and I was asked to participate. For those who haven't seen them before, a Grok Talk is a quick (ten minutes or less) talk on a small topic, with a focus on demonstrating just a little bit of code or a little technique people can use in their projects. Now normally, I have a bit of Ent in me: ten minutes is scarcely enough time to say good morning. But when I needed to come up with a topic for my Grok Talk and I hadn't enough time to think through it, I said, "Text to speech." And then afterwards, I thought about it, and realized: with Microsoft Speech API (SAPI) 5.1, text-to-speech takes three lines of code. Literally:
ISpVoice mVoice = new SpVoiceClass();
uint uiStream;
mVoice.Speak("Hello, world!", 1, out uiStream);
And one of those lines is a variable declaration! So this topic would take me less than a minute to cover. Whatever would I do with the remaining nine minutes?
So being the Tablet PC guy that I am, I decided to mix in some Ink capabilities as well. So I had a vision of an application that would speak whatever the user writes.
And thus, with some additional thought and design and coding, was born
Vox: A text-to-speech application for keyboard and pen; and once I wrote it, I decided to use it as a springboard for discussing Ink and Speech programming under .NET.
Vox is available free to anyone who's interested. I haven't tested it on a non-Tablet PC yet; but it's supposed to work just as well there, because I detect at run time whether the computer has the Tablet PC OS or not, and fall back to non-Tablet mode if not. You can type any message (or write it on a Tablet PC), and Vox will speak the message. It will also remember every message, so that you can repeat a message easily. And it has a user-editable list of Quick Words at the bottom of the form, so that you can tap a word or phrase to say it without writing or typing.
If you like Vox, let me know; and if you would like to learn about the code...
I started by creating a WinForms app. Then I added a reference to the SAPI COM DLL. That provides basic speech capabilities. Then I added the voice:
///
/// Voice for speaking.
///
private static ISpVoice mVoice = new SpVoiceClass();
ISpVoice is the SAPI interface for text-to-speech, and SpVoiceClass is the class that implements it.
Next I added the InkEdit control, a Tablet PC control that accepts text input through either the keyboard or the pen. But InkEdit inherits from RichTextBox, which is a standard WinForms control. So I used the .NET Assembly class to attempt to load the Tablet PC Ink library, and create an InkEdit control; and if that failed at any step, I just created a RichTextBox instead:
// Create the Ink Edit or Rich Text. We can't do
// this in InitializeComponent because we want to
// support InkEdit on Tablets or just RichTextBox
// on non-Tablets.
try
{
Assembly a = Assembly.Load("Microsoft.Ink, Version=1.7.2600.2180, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
this.txtVox = a.CreateInstance(
"Microsoft.Ink.InkEdit") as RichTextBox;
}
catch(Exception ex)
{
this.txtVox = new RichTextBox();
}
Next I added a handler for the TextChanged event of the text box:
///
/// User changed text, either via voice or keyboard.
/// Get ready to speak.
///
/// Stock.
/// Stock.
private void txtVox_TextChanged(object sender, EventArgs e)
{
// We can't speak right away. If the user is typing,
// we'll get this message on every character. That
// would be REALLY annoying. So instead, we'll start
// or restart a timer, and speak when we pause.
StartTimer();
}
As per the comments, I chose not to make Vox speak after every TextChanged event. That would make it speak o n e l e t t e r a t a t i m e , which would be really annoying. Instead, I start (or restart) a delay timer. (It defaults to one second, but the user can choose half a second or two seconds). If no new text comes in before the timer expires,
then I make Vox speak:
///
/// When the timer expires, speak the new text.
///
/// Stock.
/// Stock.
private void tmrVox_Tick(object sender, EventArgs e)
{
SpeakNewText();
}
The SpeakNewText method ensures that we only speak the
new text:
///
/// Speak the text that has changed since the last call
/// to this method.
///
private void SpeakNewText()
{
// Turn off the timer.
tmrVox.Enabled = false;
// Assume the full current text.
string message = txtVox.Text.Trim();
// Strip out prior text.
if (!string.IsNullOrEmpty(mLastMessage))
{
// Find the prior text.
int idxPrevious = message.IndexOf(mLastMessage);
if (idxPrevious != -1)
{
// If it's at the start or end, strip it off.
if (idxPrevious == 0)
{
message = message.Substring(
idxPrevious + mLastMessage.Length);
}
else if ((idxPrevious + mLastMessage.Length) >= message.Length)
{
message = message.Substring(0,
idxPrevious);
}
}
}
// Remember this for next time.
mLastMessage = txtVox.Text.Trim();
// Speak!
SpeakMessage(message, true);
}
First it searches for the old text within the current text:
// Assume the full current text.
string message = txtVox.Text.Trim();
// Strip out prior text.
if (!string.IsNullOrEmpty(mLastMessage))
{
// Find the prior text.
int idxPrevious = message.IndexOf(mLastMessage);
if (idxPrevious != -1)
{
Then if the old text was found at either the start or end of the current text, it's stripped off:
// If it's at the start or end, strip it off.
if (idxPrevious == 0)
{
message = message.Substring(
idxPrevious + mLastMessage.Length);
}
else if ((idxPrevious + mLastMessage.Length)
>= message.Length)
{
message = message.Substring(0,
idxPrevious);
}
And then we store the current text for next time; and then we speak the remainder with SpeakMessage:
///
/// Speak a message and store it for recall.
///
///
/// True to add to the prior message log.
public static void SpeakMessage(string message,bool record)
{
// Test for invalid message.
if (message == null)
{
throw new ArgumentNullException("message");
}
// Test for empty message.
message = message.Trim();
if (!string.IsNullOrEmpty(message))
{
// Say it!
uint uiStream;
mVoice.Speak(message, 1, out uiStream);
// Record it.
if ((record) &&
(!sActiveForm.tcboxPrevious.Items.Contains(
message)))
{
sActiveForm.tcboxPrevious.Items.Insert(0,
message);
sActiveForm.tcboxPrevious.SelectedIndex = -1;
}
}
}
The core of this method is this call:
// Say it!
uint uiStream;
mVoice.Speak(message, 1, out uiStream);
The speak method performs the text-to-speech. The message parameter tells it what to speak. The uiStream output parameter will receive the stream number, which will increase as multiple Speak calls queue up. And the flag value, 1, indicates that we want asynchronous speech, allowing us to continue typing or writing while Vox speaks.
The other important feature we need is a way to stop speaking. Imagine you have a page of text, and Vox has just finished speaking; and then imagine that you delete the last character from it. Then as SpeakNewText is written above, the old text will be longer than the new text, and so won't be found within it; so the entire page of text will be spoken again. Now I think that this design is the best we can do, over all, but we don't want to hear the whole page over again. So Vox includes a stop button.
Now what's interesting is that ISpVoice doesn't include a Cancel or Stop method. There's no direct way to stop the voice once it's speaking. But ISpVoice does include two other useful methods: GetStatus and Skip. GetStatus allows you to test whether the voice is speaking; and skip allows you to skip ahead by some unit of speech. (The only unit supported in SAPI 5.1 is SENTENCE.) So our Stop method looks like this:
///
/// Stop speaking the current message.
///
public static void StopSpeaking()
{
// Get the status.
SPVOICESTATUS vstat;
string mark;
mVoice.GetStatus(out vstat, out mark);
// While still speaking, skip ahead.
while (vstat.dwRunningState == 2)
{
// Skip 1000 sentences. There appears to be no
// harm in skipping past the end.
uint ui;
mVoice.Skip("SENTENCE", 1000, out ui);
// Get the status again.
mVoice.GetStatus(out vstat, out mark);
}
}
Originally, I made it skip ahead 1 sentence. That worked well for small pages; but I found that in longer pages, it would speak the first fractional syllable of many of the sentences, which would be really annoying. With a little experimentation, I found that there are no errors that occur if you skip too far and pass the end of the queued up Speak calls. So to be really sure to quit quickly, I jump ahead by 1000 sentences.
Now there's more to Vox than that; but the rest of it is pretty straightforward WinForms programming. These are the parts that really show a little bit of Ink and Voice programming. If you would like to see the rest of the source code, leave me a comment, and I can send it to you.
