Synthèse et reconnaissance vocale en .Net

La reconnaissance vocale est un concept utilisé pour interagir avec une application (homme parle à machine). Et pour avoir une interaction complète, il convient d'utiliser la synthèse vocale (machine parle à homme).
Ces deux concepts seront identifiés en tant que SR et TTS. SR pour la reconnaissance vocale (Speech Recognition) et TTS pour la synthèse vocale (Text-To-Speech).

La voix n'est généralement utilisée que par les "grandes" entreprises pour certaines de leurs applications internes ou alors dans des applications basées sur la reconnaissance vocale (Dragon Naturally Speaking, etc). Toutes ces applications utilisent généralement leur propre moteur vocal, comme il existe également des sociétés qui se sont spécialisées dans la création et la vente de ces moteurs.

Avant d'aller plus loin dans la lecture de cet article, il vous est nécessaire de télécharger et d'installer le Speech SDK 5.1.
Décompressez et installez-le.
Nous ne nous intéressons qu'à un fichier dll : le fichier sapi.dll qui se trouve par défaut dans le répertoire "C:\Program Files\Fichiers communs\Microsoft Shared\Speech".

Windows possède de base un moteur de reconnaissance vocale, mais plus limité. Vous devez alors configurer Windows pour qu'il utilise le moteur du Speech SDK.

Libre à vous d'utiliser le moteur vocal de votre choix, néanmoins même si le speech SDK est limité (langue anglaise uniquement (plus chinois et japonais avec un "addon" complémentaire). Ne gère pas le français ou toute autre langue), ce dernier est gratuit et donc plus facilement utilisable.
Chaque personne a une voix bien différente de celle de son voisin, c'est pourquoi le moteur vocal de base peut ne pas reconnaitre les mots de certaines personnes. D'ailleurs, certaines personnes ont des voix tellement particulières qu'elles ne seront jamais reconnues correctement par des moteurs vocaux. La plupart des moteurs dont le Speech SDK, possèdent un assistant d'apprentissage, et je vous encourage donc à créer dans le panneau de config (voir image ci-dessus) un nouveau profil personnel. Vous devrez alors suivre un assistant d'apprentissage, qui prend à peu près 10 minutes, mais qui améliorera sensiblement la qualité de la reconnaissance du moteur.
Pensez aussi à configurer le microphone, en configurant sa sensibilité, le bruit ambiant sera moins gênant.

Votre SDK est installé et configuré, il ne vous reste plus qu'à l'appeler dans votre application. Pour cela, ouvrez votre solution, et ajoutez une référence en parcourant les dossiers et en allant chercher la dll sapi.dll. N'oubliez pas la clause using dans votre code source.

using SpeechLib;

La reconnaissance vocale se fait à partir de deux composants, ici deux objets. Nous avons tout d'abord le contexte de reconnaissance (Recognition Context) ainsi que la grammaire, cette dernière gère les mots qui seront reconnus.
Le composant est assez simple à implémenter et pourtant, il fait tout le travail d'écoute (quand la grammaire analysera l'acceptation des terminaux ou non). Ce composant, c'est l'objet ISpeechRecoContext. Plus précisément, nous allons instancier une classe qui implémente cette interface : SpSharedRecoContextClass. Son implémentation est on ne peut plus simple :

monRecoContext = new SpSharedRecoContextClass();

Et… c'est tout. Nous rappellerons cet objet par la suite, mais aucune modification ne nécessite de lui être apportée.

Le deuxième composant important de la reconnaissance vocale est la grammaire. Une grammaire est une suite de règles et de terminaux ("mots") qui définissent le comportement du moteur utilisant cette grammaire. Sans le savoir, vous utilisez des grammaires régulièrement, même en parlant, et pas simplement au sens de faute de "grammaire", mais toute logique du langage (agencement des mots, etc.). De même, les compilateurs utilisent des grammaires pour la reconnaissance syntaxique, ou lexicale par exemple.
Pour notre reconnaissance vocale, nous utiliserons donc également une grammaire.

La première étape consiste à créer un objet grammaire: ISpeechRecoGrammar puis à l'initialiser à partir de notre contexte de reconnaissance :

maGrammaire =  monRecoContext.CreateGrammar(0);

Notre grammaire sera de type statique puisque nous la définissons à l'exécution et qu'elle est définie dans le code :

maGrammaire.DictationLoad("",SpeechLoadOption.SLOStatic);

Puis nous devons impérativement l'activer :

maGrammaire.DictationSetState(SpeechRuleState.SGDSActive);

À ce moment précis, notre contexte de reconnaissance est fonctionnel, il réagira à chaque règle de notre grammaire. Néanmoins, notre grammaire est vide, et il nous faut la remplir.
Créons une première règle :

ISpeechGrammarRule maRègleGood = maGrammaire.Rules.Add("RegleGood", 
                                                        SpeechRuleAttributes.SRATopLevel |  
                                                        SpeechRuleAttributes.SRADefaultToActive,0);

Puis nous allons définir le mot pour lequel cette règle sera déclenchée :

object proper = "";
maRègleGood.InitialState.AddWordTransition(null,"good"," ",SpeechGrammarWordType.SGLexical,"proGood",0,ref proper,(float)1);

Voyons plus en détail ce que nous avons codé. Nous avons d'abord ajouté une règle dont le nom est "RegleGood", qui est active par défaut (SRADefaultToActive) et qui est "Top Level"(SRATopLevel), ce qui signifie qu'elle pourra être activée ou désactivée par programmation.
Nous avons alors ajouté un mot à cette grammaire. Ce mot est le mot "good" et dont le nom de propriété est "proGood".

L'application est alors fonctionnelle et réagira lorsqu'elle reconnaitra le mot "good". Néanmoins, cette manière de déclarer tous les mots dans le code peut être longue et fastidieuse et nous allons voir dans le chapitre suivant comment s'en passer.

Il existe une autre grammaire: la grammaire dynamique. Celle-ci se fait à l'aide d'un fichier XML et a l'avantage de pouvoir être modifiée sans recompiler l'application. Plus encore, il est possible de doter l'application d'un panneau "options" permettant de modifier cette grammaire.
Voyons plus avant, son fonctionnement et son utilisation.

III-C-1. Syntaxe de la grammaire▲

<GRAMMAR LANGID="409">
 <RULE NAME="developpez" TOPLEVEL="ACTIVE">
    <P>developpez</P>  
 </RULE>
 <RULE NAME="message" TOPLEVEL="ACTIVE">
    <P>message</P>  
 </RULE>
 <RULE NAME="hide" TOPLEVEL="ACTIVE">
    <P>hide </P>  
 </RULE>
 <RULE NAME="exit" TOPLEVEL="ACTIVE">
    <L>
     <P>exit</P> 
     <P>close</P>
    </L>
 </RULE>
</GRAMMAR>

III-C-2. Utilisation d'une grammaire dynamique▲

maGrammaireXML =  monRecoContextXML.CreateGrammar(0);

maGrammaireXML.CmdLoadFromFile(Application.StartupPath + @"\grammaire.xml",SpeechLoadOption.SLODynamic);

    maGrammaireXML.CmdSetRuleIdState(0, SpeechRuleState.SGDSActive);

Vous devez savoir qu'à partir du moment où vous créez votre contexte et vous activez une grammaire, le moteur de reconnaissance "tourne" et écoute constamment. Néanmoins, nous n'avons pas encore défini quand interagir et surtout, comment interagir.
Nous allons donc ajouter des évènements à notre contexte de reconnaissance. L'évènement qui nous intéressera le plus est l'évènement Recognition :

monRecoContext.Recognition += new _ISpeechRecoContextEvents_RecognitionEventHandler(HandlerReco);

Il nous reste plus qu'à écrire la méthode appelée par notre évènement (méthode HandlerReco())

#region HandlerReco
private void HandlerReco(int StreamNumber, object StreamPosition, SpeechRecognitionType RecognitionType, 
                         ISpeechRecoResult result)
{
...
}
#endregion

Cette méthode est appelée à CHAQUE fois qu'un mot est "reconnu", pas autrement. C'est-à-dire, que pour une grammaire de 2,3 ou 100000 mots à reconnaitre, nous n'aurons qu'une seule méthode.
Dans les paramètres de cette méthode, nous nous intéresserons principalement au dernier: l'objet ISpeechRecoResult. À partir de ce dernier, nous pourrons récupérer le mot reconnu et la règle déclenchée (puisqu'il peut y avoir plusieurs mots pour une même règle).

string entrée = result.PhraseInfo.GetText(0,-1,true);
string regle = result.PhraseInfo.Rule.Name;

Il ne vous reste plus, probablement à l'aide d'un switch case, qu'à exécuter les méthodes souhaitées en fonction de la règle déclenchée :

switch(regle)
{
    case "RegleGood":MessageBox.Show("le mot reconnu est "+entrée);
                     break;
    case "RegleHello":MessageBox.Show("Hello");
                     break;
    default : break;
}

À ce niveau-là, vos libertés sont infinies, du simple MsgBox, à la synthèse vocale en passant par une suite complète de méthodes diverses et variées.