Introduction

OpenEars is an shared-source iOS framework for iPhone voice recognition and speech synthesis (TTS). It lets you easily implement round-trip English language speech recognition and text-to-speech on the iPhone and iPad and uses the open source CMU Pocketsphinx, CMU Flite, and CMUCLMTK libraries, and it is free to use in an iPhone or iPad app. It is the most popular offline framework for speech recognition and speech synthesis on iOS and has been featured in development books such as O'Reilly's Basic Sensors in iOS by Alasdair Allan and Cocos2d for iPhone 1 Game Development Cookbook by Nathan Burba.

The OpenEars Platform is also a complete development platform for creating your speech recognition and text-to-speech apps including both the free OpenEars SDK documented on this page and a diverse set of plugins that can be added to OpenEars in order to extend and refine its default features: you can read more about the OpenEars platform here. This page is all about the free and shared-source OpenEars SDK, to please read on to learn more about it.

Highly-accurate large-vocabulary recognition (that is, trying to recognize any word the user speaks out of many thousands of known words) is not yet a reality for local in-app processing on the iPhone given the hardware limitations of the platform; even Siri does its large-vocabulary recognition on the server side. However, Pocketsphinx (the open source voice recognition engine that OpenEars uses) is capable of local recognition on the iPhone of vocabularies with hundreds of words depending on the environment and other factors, and performs very well with command-and-control language models. The best part is that it uses no network connectivity because all processing occurs locally on the device.

The current version of OpenEars is 1.2.5. Download OpenEars 1.2.5 or read its changelog.

If you want to try out Pocketsphinx and Sphinxbase .8, you can also try out the OpenEars 1.3.0 preview here, just keep in mind that it's a preview and could have issues, which you can report in the forums.

Features of OpenEars

OpenEars can:

• Listen continuously for speech on a background thread, while suspending or resuming speech processing on demand, all while using less than 4% CPU on average on an iPhone 4 (decoding speech, text-to-speech, updating the UI and other intermittent functions use more CPU),
• Use any of 9 voices for speech, including male and female voices with a range of speed/quality level, and switch between them on the fly,
• Change the pitch, speed and variance of any text-to-speech voice,
• Know whether headphones are plugged in and continue voice recognition during text-to-speech only when they are plugged in,
• Support bluetooth audio devices (experimental),
• Dispatch information to any part of your app about the results of speech recognition and speech, or changes in the state of the audio session (such as an incoming phone call or headphones being plugged in),
• Deliver level metering for both speech input and speech output so you can design visual feedback for both states.
• Support JSGF grammars,
• Dynamically generate new ARPA language models in-app based on input from an NSArray of NSStrings,
• Switch between ARPA language models or JSGF grammars on the fly,
• Get n-best lists with scoring,
• Test existing recordings,
• Be easily interacted with via standard and simple Objective-C methods,
• Control all audio functions with text-to-speech and speech recognition in memory instead of writing audio files to disk and then reading them,
• Drive speech recognition with a low-latency Audio Unit driver for highest responsiveness,
• Be installed in a Cocoa-standard fashion using an easy-peasy already-compiled framework.
• In addition to its various new features and faster recognition/text-to-speech responsiveness, OpenEars now has improved recognition accuracy.
• OpenEars is free to use in an iPhone or iPad app.

Warning

Before using OpenEars, please note it has to use a different audio driver on the Simulator that is less accurate, so it is always necessary to evaluate accuracy on a real device. Please don't submit support requests for accuracy issues with the Simulator.

Installation

To use OpenEars:

• Download the distribution and unpack it.

• Create your own app, and add the iOS frameworks AudioToolbox and AVFoundation to it.

• Inside your downloaded distribution there is a folder called "Frameworks". Drag the "Frameworks" folder into your app project in Xcode.

OK, now that you've finished laying the groundwork, you have to...wait, that's everything. You're ready to start using OpenEars. Give the sample app a spin to try out the features (the sample app uses ARC so you'll need a recent Xcode version) and then visit the Politepix interactive tutorial generator for a customized tutorial showing you exactly what code to add to your app for all of the different functionality of OpenEars.

If the steps on this page didn't work for you, you can get free support at the forums, read the FAQ, brush up on the documentation, or open a private email support incident at the Politepix shop. If you'd like to read the documentation, simply read onward.

Basic concepts

There are a few basic concepts to understand about voice recognition and OpenEars that will make it easiest to create an app.

• Local or offline speech recognition versus server-based or online speech recognition: most speech recognition on the iPhone is done by streaming the speech audio to servers. OpenEars works by doing the recognition inside the iPhone without using the network. This saves bandwidth and results in faster response, but since a server is much more powerful than a phone it means that we have to work with much smaller vocabularies to get accurate recognition.

• Language Models. The language model is the vocabulary that you want OpenEars to understand, in a format that its speech recognition engine can understand. The smaller and better-adapted to your users' real usage cases the language model is, the better the accuracy. An ideal language model for PocketsphinxController has fewer than 200 words.
• The parts of OpenEars. OpenEars has a simple, flexible and very powerful architecture.

PocketsphinxController recognizes speech using a language model that was dynamically created by LanguageModelGenerator. FliteController creates synthesized speech (TTS). And OpenEarsEventsObserver dispatches messages about every feature of OpenEars (what speech was understood by the engine, whether synthesized speech is in progress, if there was an audio interruption) to any part of your app.

The class that controls speech synthesis (TTS) in OpenEars.

Usage examples

Preparing to use the class:

To use FliteController, you need to have at least one Flite voice added to your project. When you added the "framework" folder of OpenEars to your app, you already imported a voice called Slt, so these instructions will use the Slt voice. You can get eight more free voices in OpenEarsExtras, available at https://bitbucket.org/Politepix/openearsextras

What to add to your header:

Add the following lines to your header (the .h file). Under the imports at the very top:

#import <Slt/Slt.h>
#import <OpenEars/FliteController.h>

In the middle part where instance variables go:

FliteController *fliteController;
Slt *slt;

In the bottom part where class properties go:

@property (strong, nonatomic) FliteController *fliteController;
@property (strong, nonatomic) Slt *slt;

What to add to your implementation:

Add the following to your implementation (the .m file): Under the @implementation keyword at the top:

@synthesize fliteController;
@synthesize slt;

Among the other methods of the class, add these lazy accessor methods for confident memory management of the object:

- (FliteController *)fliteController {
	if (fliteController == nil) {
		fliteController = [[FliteController alloc] init];
	}
	return fliteController;
}

- (Slt *)slt {
	if (slt == nil) {
		slt = [[Slt alloc] init];
	}
	return slt;
}

How to use the class methods:

In the method where you want to call speech (to test this out, add it to your viewDidLoad method), add the following method call:

[self.fliteController say:@"A short statement" withVoice:self.slt];

Warning

There can only be one FliteController instance in your app at any given moment.

The class that generates the vocabulary the PocketsphinxController is able to understand.

Usage examples

What to add to your implementation:

Add the following to your implementation (the .m file): Under the @implementation keyword at the top:

#import <OpenEars/LanguageModelGenerator.h>

Wherever you need to instantiate the language model generator, do it as follows:

LanguageModelGenerator *lmGenerator = [[LanguageModelGenerator alloc] init];

How to use the class methods:

In offline speech recognition, you define the vocabulary that you want your app to be able to recognize. A good vocabulary size for an offline speech recognition app on the iPhone is between 3 and 300 words.

In the method where you want to create your language model (for instance your viewDidLoad method), add the following method call (replacing the placeholders like "WORD" and "A PHRASE" with actual words and phrases you want to be able to recognize):

NSArray *words = [NSArray arrayWithObjects:@"WORD", @"STATEMENT", @"OTHER WORD", @"A PHRASE", nil];
NSString *name = @"NameIWantForMyLanguageModelFiles";
NSError *err = [lmGenerator generateLanguageModelFromArray:words withFilesNamed:name];


NSDictionary *languageGeneratorResults = nil;

NSString *lmPath = nil;
NSString *dicPath = nil;
	
if([err code] == noErr) {
	
	languageGeneratorResults = [err userInfo];
		
	lmPath = [languageGeneratorResults objectForKey:@"LMPath"];
	dicPath = [languageGeneratorResults objectForKey:@"DictionaryPath"];
		
} else {
	NSLog(@"Error: %@",[err localizedDescription]);
}

If you are using the default English-language model generation, it is a requirement to enter your words and phrases in all capital letters, since the model is generated against a dictionary in which the entries are capitalized (meaning that if the words in the array aren't capitalized, they will not match the dictionary and you will not have the widest variety of pronunciations understood for the word you are using). If you need to create a fixed language model ahead of time instead of creating it dynamically in your app, just use this method (or generateLanguageModelFromTextFile:withFilesNamed:) to submit your full language model using the Simulator and then use the Simulator documents folder script to get the language model and dictionary file out of the documents folder and add it to your app bundle, referencing it from there.

OpenEarsEventsObserver provides a large set of delegate methods that allow you to receive information about the events in OpenEars from anywhere in your app. You can create as many OpenEarsEventsObservers as you need and receive information using them simultaneously. All of the documentation for the use of OpenEarsEventsObserver is found in the section OpenEarsEventsObserverDelegate.

A singleton which turns logging on or off for the entire framework. The type of logging is related to overall framework functionality such as the audio session and timing operations. Please turn OpenEarsLogging on for any issue you encounter. It will probably show the problem, but if not you can show the log on the forum and get help.

Warning

The individual classes such as PocketsphinxController and LanguageModelGenerator have their own verbose flags which are separate from OpenEarsLogging.

The class that controls local speech recognition in OpenEars.

Usage examples

Preparing to use the class:

To use PocketsphinxController, you need a language model and a phonetic dictionary for it. These files define which words PocketsphinxController is capable of recognizing. They are created above by using LanguageModelGenerator.

What to add to your header:

Add the following lines to your header (the .h file). Under the imports at the very top:

#import <OpenEars/PocketsphinxController.h>

In the middle part where instance variables go:

PocketsphinxController *pocketsphinxController;

In the bottom part where class properties go:

@property (strong, nonatomic) PocketsphinxController *pocketsphinxController;

What to add to your implementation:

Add the following to your implementation (the .m file): Under the @implementation keyword at the top:

@synthesize pocketsphinxController;

Among the other methods of the class, add this lazy accessor method for confident memory management of the object:

- (PocketsphinxController *)pocketsphinxController {
	if (pocketsphinxController == nil) {
		pocketsphinxController = [[PocketsphinxController alloc] init];
	}
	return pocketsphinxController;
}

How to use the class methods:

In the method where you want to recognize speech (to test this out, add it to your viewDidLoad method), add the following method call:

[self.pocketsphinxController startListeningWithLanguageModelAtPath:lmPath dictionaryAtPath:dicPath languageModelIsJSGF:NO];

Warning

There can only be one PocketsphinxController instance in your app.

OpenEarsEventsObserver provides a large set of delegate methods that allow you to receive information about the events in OpenEars from anywhere in your app. You can create as many OpenEarsEventsObservers as you need and receive information using them simultaneously.

Usage examples

What to add to your header:

Add the following lines to your header (the .h file). Under the imports at the very top:

#import <OpenEars/OpenEarsEventsObserver.h>

at the @interface declaration, add the OpenEarsEventsObserverDelegate inheritance. An example of this for a view controller called ViewController would look like this:

@interface ViewController : UIViewController <OpenEarsEventsObserverDelegate> {

In the middle part where instance variables go:

OpenEarsEventsObserver *openEarsEventsObserver;

In the bottom part where class properties go:

@property (strong, nonatomic) OpenEarsEventsObserver *openEarsEventsObserver;

What to add to your implementation:

Add the following to your implementation (the .m file): Under the @implementation keyword at the top:

@synthesize openEarsEventsObserver;

Among the other methods of the class, add this lazy accessor method for confident memory management of the object:

- (OpenEarsEventsObserver *)openEarsEventsObserver {
	if (openEarsEventsObserver == nil) {
		openEarsEventsObserver = [[OpenEarsEventsObserver alloc] init];
	}
	return openEarsEventsObserver;
}

and then right before you start your first OpenEars functionality (for instance, right before your first self.fliteController say:withVoice: message or right before your first self.pocketsphinxController startListeningWithLanguageModelAtPath:dictionaryAtPath:languageModelIsJSGF: message) send this message:

[self.openEarsEventsObserver setDelegate:self];

How to use the class methods:

Add these delegate methods of OpenEarsEventsObserver to your class:

- (void) pocketsphinxDidReceiveHypothesis:(NSString *)hypothesis recognitionScore:(NSString *)recognitionScore utteranceID:(NSString *)utteranceID {
	NSLog(@"The received hypothesis is %@ with a score of %@ and an ID of %@", hypothesis, recognitionScore, utteranceID);
}

- (void) pocketsphinxDidStartCalibration {
	NSLog(@"Pocketsphinx calibration has started.");
}

- (void) pocketsphinxDidCompleteCalibration {
	NSLog(@"Pocketsphinx calibration is complete.");
}

- (void) pocketsphinxDidStartListening {
	NSLog(@"Pocketsphinx is now listening.");
}

- (void) pocketsphinxDidDetectSpeech {
	NSLog(@"Pocketsphinx has detected speech.");
}

- (void) pocketsphinxDidDetectFinishedSpeech {
	NSLog(@"Pocketsphinx has detected a period of silence, concluding an utterance.");
}

- (void) pocketsphinxDidStopListening {
	NSLog(@"Pocketsphinx has stopped listening.");
}

- (void) pocketsphinxDidSuspendRecognition {
	NSLog(@"Pocketsphinx has suspended recognition.");
}

- (void) pocketsphinxDidResumeRecognition {
	NSLog(@"Pocketsphinx has resumed recognition."); 
}

- (void) pocketsphinxDidChangeLanguageModelToFile:(NSString *)newLanguageModelPathAsString andDictionary:(NSString *)newDictionaryPathAsString {
	NSLog(@"Pocketsphinx is now using the following language model: \n%@ and the following dictionary: %@",newLanguageModelPathAsString,newDictionaryPathAsString);
}

- (void) pocketSphinxContinuousSetupDidFail { // This can let you know that something went wrong with the recognition loop startup. Turn on OPENEARSLOGGING to learn why.
	NSLog(@"Setting up the continuous recognition loop has failed for some reason, please turn on OpenEarsLogging to learn more.");
}