Tutoriel : Utilisation des API Speech du Framework .NET en C# avec Windows 7

Partie 1 : La synthèse vocale

Téléchargez le tutorial et la source

Article par Eric Vernié Microsoft France Division Plate-forme & Ecosystème Je rencontre les développeurs pour leur faire partager ma passion pour le développement autour des technologies .NET sans oublier le monde natif autour des Apis Win32. J'ai également en charge la préparation de certains contenus pour des séminaires tel que les TechDays. Retrouvez moi sur les centres de développement Visual C++, Le Framework .NET, ainsi que le site sécurité.

Sommaire de l'article

• Introduction
  • La synthèse vocale
• Pré requis
• Tutoriel synthèse vocale
  • Création du projet CSharp
  • Exercice 1 : Vérification des langages installés
  • Exercice 2 : Synthétiser un texte simple
  • Exercice 3 : Utilisation des méthodes asynchrones pour synthétiser un texte
  • Exercice 4 : Utilisation du PromptBuilder
  • Exercice 5 : Utilisation du standard SSML
• Conclusion

Introduction

La synthèse et reconnaissance vocale est un sujet qui préoccupe Microsoft depuis des décennies. En 1993 elle a d'ailleurs engagé trois des personnes responsables du système de reconnaissance vocale de Carnegie Mellon, qui a atteint une renommée mondiale en 1992 en raison de sa précision sans précédant. Ce qui a conduit la société à créer en 1994 uneéquipe de développement de Speech API (SAPI) 1.0. L'équipe à continuée de croitre au fil des ans et à faire évoluer la plate-forme jusqu'à aujourd'hui. On retrouve cette technologie sur les serveurs (Speech Serveur et maintenant Lync) mais aussi sur les mobiles avec Voice Commander. Pour en savoir plus sur les différentes technologies Speech, n'hésitez pas à aller à l'adresse : http://www.microsoft.com/en-us/Tellme/developers/default.aspx

Ce n’est donc pas une technologie nouvelle dans Windows, mais elle arrive aujourd’hui à un degré de maturation qui permet de piloter, ou de faire lire un texte à Windows de manière fluide et cohérente.

Windows 7, fournit lui-même la fonctionnalité de reconnaissance vocale, qui permet de le piloter ou de dicter un texte.

Une phase d’apprentissage est nécessaire pour qu’il reconnaisse correctement votre voix et intonation et puis c’est tout. Windows 7 va alors vous obéir au doigt et à l’œil.

Il est important de comprendre que le concept des API Speech, englobe deux technologies, qui peuvent être utilisées indépendamment l'une de l'autre.

• La synthèse vocale
• La reconnaissance vocale (que nous aborderons dans la 2ième partie de ce tutoriel)
  

La synthèse vocale

C’est la possibilité de lire un texte, ce que les Anglo-Saxon appellent Text To Speech (TTS) et de le restituer sur le périphérique audio.
Elle peut servir pour des scénarios simples, de lecture de mail, de messages instantanés, de messages vocaux, pour des jeux, des applications pour handicapés, pour de l'apprentissage de langues étrangères, ou de la lecture de livres électroniques.
Comment ça marche ?.
Un document, sous forme de chaine de caractères est utilisé en entrée. Avec les API .NET ce document peut provenir de différentes sources. Un texte simple, une URI, un fichier audio, un Prompt ou PromptBuilder, ou alors un texte au format SSML (Speech Synthesis Markup Language).
Nous verrons plus en détails le format SSML par la suite, mais pour les plus curieux vous pouvez d’ores et déjà visiter la page du W3C http://www.w3.org/TR/speech-synthesis/.
Le standard SSML est constitué de balises XML, qui permettent de contrôler différents aspects, tels, que l'intonation, la prononciation, la vitesse de lecture etc..

Le texte est fourni à un processeur (front-end) de langage naturel, qui est en charge d'analyser la chaîne de caractères afin de découvrir la position des mots, le type des mots (nom propres, nombres, ponctuation etc.), le début et la fin des phrases, si c'est une question ou un texte simple, et a quel temps (passé, présent future) est la phrase. Tous ces éléments sont critiques, pour une intonation et prononciation approprié, sachant que la multitude de langage complique considérablement le travail du front-end.

Le processeur audio (back-end) est alimenté par le front-end, et génère sa propre analyse, afin de créer le son approprié. Pour éviter des sons trop "robotique", les synthétiseurs modernes, tel que celui de Windows 7, utilise une base de données de segments de sons, construite à partir d'enregistrements préalables. L'efficacité du back-end, dépend de la précision qu'il aura lors de la sélection de ces segments.

Ce que nous allons faire dans ce tutoriel, c’est apprendre à piloter une application .NET, qui réagira à des commandes vocales (Reconnaissance Vocale qui sera abordée dans la seconde partie de ce tutoriel), pour lire un texte (Synthèse Vocale).
Pour ajouter ce type de fonctionnalité à l’application, il est possible d’utiliser les APIS .NET suivantes :

• Soit les API du poste client System.Speech, fournit avec la plate-forme .NET 4.0, qui permet de piloter le moteur vocale de Windows 7
• Soit les API serveur Microsoft.Speech, fournit avec le Kit de développement Unified Communications API (UCMA 3.0) qui permet de piloter le moteur vocale fournit avec Microsoft Lync, et qui tourne parfaitement sur un Client Windows 7.

Pré requis

Pour réaliser les exemples de cet article il vous faut :

• Visual Studio C# Express
• Windows 7 en Français. Si vous avez une version Anglaise, il est facile d’installer le pack de langue Française à partir de Windows Update. Néanmoins seule la langue Française pour la reconnaissance vocale sera disponible, mais toujours pas de langue Française pour la synthèse vocale. Il vous faut alors acheter une voie Française sinon télécharger gratuitement la voie Virginie. (La voie Virginie est fourni avec le code source de cet article)
  
• Si vous souhaitez utiliser également Microsoft.Speech vous devez télécharger et installer les composants suivants :
• Microsoft Speech Platform Server SDK (10.2)
• Microsoft Speech Platform Runtime Server (10.2)
• Microsoft Speech Platform – Languages (10.2) en choisissant :
• • MSSpeech_SR_fr-FR_TELE.msi pour la reconnaissance vocale française
  • MSSpeech_TTS_fr-FR_Hortense.msi pour la synthèse vocale Française
    

Tutoriel synthèse vocale

Comme je le disais en introduction, il existe deux jeux d’API permettant de faire de la synthèse vocale. Nous allons donc les utiliser, toutes les deux, mais attention, ce n’est pas une nécessité. Les deux API présentes une nomenclature identique, l'utilisation d'une constante de compilation nous permettra de commuter entre les deux.

Création du projet CSharp

1. Dans Visual Studio Express, créez un nouveau projet de type WPF, comme illustré sur la figure suivante :
   
   
   
   
2. Ajoutez une référence à :System.Speech
   
   
   
   
3. Puis ajoutez une référence à Microsoft.Speech.dll qui se trouve dans le répertoire
   C:\Program Files\Microsoft Speech Platform SDK\Assembly\ (après avoir installé le kit de développement Microsoft Speech Platform Server SDK (10.2))
   
   
   
   
   Encore une fois cette dernière étape n’est pas nécessaire si vous ne souhaitez pas utiliser cette API.
   
4. Maintenant, nous allons déclarer une constante de compilation, qui va nous permettre de commuter entre les deux API, puis déclarer les espaces de noms en conséquence.
5. 1. Affichez le code du fichier MainWindow.xaml
   2. Ajoutez le code suivant :
      #define MICROSOFT_SPEECH
      #if MICROSOFT_SPEECH
      using Microsoft.Speech;
      using Microsoft.Speech.Synthesis;
      #else
      using System.Speech;
      using System.Speech.Synthesis;
      #endif
      La constante de compilation MICROSOFT_SPEECH est définie, comme nous pouvons le constater, c’est l’API Microsoft.Speech qui sera utilisée (l’API System.Speech apparait en grisée c’est-à-dire que le compilateur n’en tiendra pas compte).
      Si la constante n’est pas définie (par exemple, si vous ajoutez un trait de soulignement à la constante), c’est l’API System.Speech qui sera utilisée
      #define_MICROSOFT_SPEECH
      #if MICROSOFT_SPEECH
      using Microsoft.Speech;
      using Microsoft.Speech.Synthetis;
      #else
      using System.Speech;
      using System.Speech.Synthesis;
      #endif
      

Notre projet est en place pour notre premier bout de code, nous allons vérifier les langages installés pour chaque API.

Exercice 1 : Vérification des langages installés

1. Ajoutez un bouton et une Listbox à la fenêtre principale comme illustré sur la figure suivante :
   
2. Activez l’évènement click du bouton et ajoutez lui le code suivant :
   
   
   
   

   private void cmdLangages_Click(object sender, RoutedEventArgs e)
   {
   SpeechSynthesizer s = new SpeechSynthesizer();
   var voix = s.GetInstalledVoices();
   foreach (InstalledVoice v in voix)
   {
   listBox1.Items.Add(v.VoiceInfo.Name);
   }
   }

   L’objet SpeechSynthetizer est l’objet de base de la synthèse vocale et nous servira dans tous les exercices suivants, mais que nous utilisons ici uniquement pour lister et afficher les langages installés.
   En fonction de l’API que vous utilisez (C’est-à-dire en fonction de la définition de la constante de compilation MICROSOFT_SPEECH), vous obtenez les langages installés.
   
   Voix installées pour System.Speech
   
   
   
    
   Note : Le langage Virginie n'apparaitra que si vous compilez en 32 Bits, si vous êtes sur un système Windows 7 64 Bits.
   
   Voix installées pour Microsoft.Speech
   
   
   
   
   A noter, que j’ai installé sur mon système la voix canadienne, ce qui n’est peut-être pas le cas chez vous.

Maintenant que nous avons les bases, nous allons synthétiser notre premier texte.

Exercice 2 : Synthétiser un texte simple

1. Ajoutez un bouton et une TextBox à la fenêtre principale, comme illustré sur la figure suivante :
   
   
   
   
2. Sur l’évènement click du bouton, ajoutez le code suivant:
3. • Pour System.Speech
     SpeechSynthesizer s = new SpeechSynthesizer();
     String texte=txtASynthetiser.Text;
     String voix="ScanSoft Virginie_Dri40_16kHz";
     s.SelectVoice(voix);
     s.Speak(texte);
   • Pour Microsoft.Speech
     SpeechSynthesizer s = new SpeechSynthesizer();
     String texte=txtASynthetiser.Text;
     String voix="Microsoft Server Speech Text to Speech Voice (fr-FR, Hortense)";
     s.SelectVoice(voix);
     s.Speak(texte);
     
   • Exécutez l’application, et entrez le texte que vous souhaitez dans la zone de texte
     
     
     
     
     

A priori la seule différence réside dans le faite que la voix sélectionnée est différente, on choisit entre Virginie et Hortense. Néanmoins je ne serais pas tout à fait honnête si je ne mentionnais pas le faite que le second exemple pour Microsoft.Speech, ne fonctionne pas, ou tout du moins, aucun son ne sort par défaut sur le périphérique audio. La raison de cela, est que Microsoft.Speech est au départ une API Serveur, et que la méthode Speak() envoi le son à un dispositif autre que la carte son. Et pour cause sur un serveur cela n’a aucun intérêt d’en avoir une. Microsoft reconnait qu’aujourd’hui puisque nous pouvons l’utiliser sur un poste client que c’est un bug et qu’il pourra être corrigé dans un avenir proche. D’accord, j’avoue, ce n’est pas fair-play, mais voici comment le contourner, et promis c’est la seule différence qu’il faut connaitre aujourd’hui entre les deux API.

Dans cet exercice, nous utilisons la version synchrone des API qui indubitablement vont figer l’interface utilisateur, lorsqu’un texte important sera à synthétiser. Dans l’exercice suivant, nous allons utiliser les méthodes asynchrones, et c’est que nous utiliserons désormais dans la suite de ce tutoriel.

Exercice 3 : Utilisation des méthodes asynchrones pour synthétiser un texte

Afin d’éviter de figer l’interface utilisateur sur des PC surpuissants dotés de plusieurs cœurs, il est impératif dans les applications modernes de développer en mode asynchrone.

1. Ajoutez un bouton comme illustré sur la figure suivante :
   
   
   
   
   
2. Sur l’évènement click du bouton, ajoutez le code suivant :
   private void cmdSynthetiserAsync_Click(object sender, RoutedEventArgs e)
   {
   SpeechSynthesizer s = new SpeechSynthesizer();
   PromptBuilder builder = new PromptBuilder(new System.Globalization.CultureInfo("fr-fr"));
   builder.AppendText(txtASynthetiser.Text);
   s.SpeakCompleted += new EventHandler(s_SpeakCompleted);
   
   #if MICROSOFT_SPEECH         
   ConfigureSoundPlayer(s);
   #endif
   s.SpeakAsync(builder);
   }
   Nous utilisons l’objet PromptBuilder, pour construire le texte à synthétiser. Vous remarquerez que dans son constructeur, nous définissons la culture qui sera utilisée. En l’occurrence le Français ce qui évitera de sélectionner la voix. Par défaut il utilisera en priorité la langue Française de culture Française installée sur le système. Si cette langue n’est pas installée, il essaiera une autre langue Française avec une autre culture, par exemple "fr-ca" (canadien), ou "fr-be" (Belge). Si aucune langue Française n’est installée, cela générera une erreur.
   Par exemple, si vous utilisez la langue Française de culture Canadienne ("fr-ca"), et que le pack de langue n’est pas installé, il utilisera la langue Française de culture Française par défaut.
   Ensuite, nous nous abonnons à l’évènement SpeakCompleted avec comme méthode de rappel s_SpeakCompleted. Comme nous le verrons à l’étape suivante, c’est dans cette méthode de rappel que nous jouerons le son si la constante de compilation MICROSOFT_SPEECH est définie. Dans le cas contraire (utilisation System.Speech) le son est joué immédiatement.
   Enfin nous appelons la méthode asynchrone SpeakAsync du synthétiseur en lui passant notre PromptBuilder.
   
3. Définissez maintenant la méthode de rappel s_SpeakCompleted.
   
   void s_SpeakCompleted(object sender, SpeakCompletedEventArgs e)
   {
   if (e.Error != null)
   {
   MessageBox.Show(e.Error.Message);
   return;
   }
   
   #if MICROSOFT_SPEECH
   JouerSoundPlayer();
   #endif
   }
   Si une erreur survient on l’affiche et on sort de la méthode. Dans le cas contraire nous jouons le son. Encore une fois uniquement si vous utilisez les API Microsoft.Speech.

Maintenant que nous venons de voir comment ne plus figer l’interface utilisateur en utilisant le mode asynchrone du synthétiseur, dans l’exercice suivant, nous allons utiliser plus en détail l’objet PromptBuilder afin de synthétiser un texte de manière plus fine.

Exercice 4 : Utilisation du PromptBuilder

Comme nous venons de le voir, un texte à jouer est relativement simple. Néanmoins, de temps en temps, il est possible d’aider le synthétiseur, afin qu’il lise le texte de manière plus fine.
Par exemple, il est possible d’ajouter de l’intonation entre chaque mot ou phrase, de l’aider à synthétiser une date, un nombre, d’épeler un mot, voir de l'aider à prononcer un mot, ou d'accélérer la vitesse de lecture.

1. Ajoutez un bouton comme illustré sur la figure suivante :
   
   
   
   
2. Sur l’évènement click du bouton, ajoutez le code suivant :
   private void cmdSynthetiserPromptBuilder_Click(object sender, RoutedEventArgs e)
   {
   SpeechSynthesizer s = new SpeechSynthesizer();
   PromptBuilder builder = new PromptBuilder(new System.Globalization.CultureInfo("fr-fr"));
   s.SpeakCompleted += new EventHandler(s_SpeakCompleted);
   builder.AppendTextWithHint(txtASynthetiser.Text, SayAs.NumberOrdinal);
   s.SpeakCompleted += new EventHandler(s_SpeakCompleted);
   #if MICROSOFT_SPEECH
   ConfigureSoundPlayer(s);
   #endif
   s.SpeakAsync(builder);
   }
   Vous noterez que j’ai utilisé la méthode AppendTextWithHint du PromptBuilder, afin de lui faire prononcer par exemple le texte "1" en "Premier". Pour ce faire j’ai utilisé l’énumération SayAs
   
   
   
   
   En tapant 1 dans la zone de texte, puis en appuyant sur le Bouton Synthétiser PromptBuilder, le synthétiseur prononce Premier, alors que sur les autres boutons il prononcera Un.
   Avec cette énumération, il est possible de lui faire prononcer correctement, l’heure, les dates, les sigles monétaires, d’épeler un mot, etc. Comme détaillé ci-dessous.
   namespace Microsoft.Speech.Synthesis
   {
   public enum SayAs
   {
   SpellOut = 0,
   NumberOrdinal = 1,
   NumberCardinal = 2,
   Date = 3,
   DayMonthYear = 4,
   MonthDayYear = 5,
   YearMonthDay = 6,
   YearMonth = 7,
   MonthYear = 8,
   MonthDay = 9,
   DayMonth = 10,
   Year = 11,
   Month = 12,
   Day = 13,
   Time = 14,
   Time24 = 15,
   Time12 = 16,
   Telephone = 17,
   Currency = 18,
   Text = 19,
   }
   }
   Il est également possible d’ajouter des silences entre chaque texte si l’on veut renforcer la ponctuation en utilisant la méthode AppendBreak, avec l’énumération PromptBreak pour gérer la durée du silence.
   builder.AppendBreak(PromptBreak.Medium);
   
   Il est également possible de renforcer la prononciation
   builder.AppendTextWithPronunciation("Endurer", "ɑ̃d̪yːˈʁe");
   Note : Pour de plus amples informations sur la phonétique française
   http://fr.advantacell.com/wiki/International_Phonetic_Alphabet
   
   On peut rajouter directement un son si on le souhaite
   builder.AppendAudio("MonFichier.Wav");
   
   Il est possible de combiner différent PromptBuilder
   PromptBuilder builder2=new PromptBuilder ();
   builder.AppendPromptBuilder(Builder2);
   
   Il est également possible d’affecter un style à toute ou partie de texte
   PromptStylestyle = new PromptStyle();
   style.Emphasis = PromptEmphasis.Strong;
   style.Rate = PromptRate.ExtraFast;
   builder.StartStyle(style);
   builder.AppendTextWithHint(txtASynthetiser.Text, SayAs.NumberOrdinal);
   builder.EndStyle();
   
   De modifier la voix en cours d’exécution
   builder.StartVoice(new System.Globalization.CultureInfo("fr-fr"));
   builder.AppendText("Ceci est un texte Français");
   builder.EndVoice();
   builder.StartVoice(new System.Globalization.CultureInfo("en-us"));
   builder.AppendText("This is an english text");
   builder.EndVoice();
   
   Enfin avec le PromptBuilder, il est possible de récupérer le texte synthétisé sous la forme d’une chaîne de caractère au format SSML. Et ça tombe bien car c’est ce que nous allons utiliser dans notre prochaine exercice.
   Stringssml=builder.ToXml();
   

Exercice 5 : Utilisation du standard SSML

Comme je le disais plus haut, le standard SSML est un standard du W3C constitué de balises XML, et qui permet de contrôler de manière fine et dynamique la manière dont la synthèse vocale sera effectuée.

Quand je dis dynamique, c’est qu’il sera possible de décrire tout ce dont nous venons de voir avec le PromptBuilder, mais cette fois-ci dans un fichier et qu’il sera possible de le charger à la volée.

Le but de cet exercice n’est pas de rentrer dans le détail des balises XML du standard SSML, vous les retrouverez à l’adresse suivante http://www.w3.org/TR/speech-synthesis/

Néanmoins pour pouvoir démarrer en voici quelques bases.

Un fichier SSML commence par la balise racine obligatoire <speak>
<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="fr-FR">

Bonjour le monde

</speak>
L’attribut version est obligatoire et doit être "1.0".

L’attribut xml:lang est obligatoire et permet de définir la culture et le langage qui sera utilisé.

Au même titre que le PromptBuilder, il est possible de lui faire prononcer un texte comme on le souhaite à l’aide de la balise <say-as>.
<say-as interpret-as="ordinal">1</say-as>
Prononce le chiffre 1 en Premier
<say-as interpret-as="date">10/03/2011</say-as>
Prononce la date en 10 Mars 2011
<say-as interpret-as="time" format="hms24">Il est exactement 12h30</say-as>

Des chiffres
<say-as interpret-as="cardinal">1</say-as>

Prononce Un

Un numéro de telephone
<say-as interpret-as="telephone">06-12-40-44-79</say-as>

D’épeler un mot
<say-as interpret-as="spell-out">EPELER</say-as>

Il est égal possible d’ajouter des silences entre chaque texte avec la balise <break>
<break strength="medium" />

D’ajouter de la prononciation avec la balise <phoneme>
<phoneme ph="ɑ̃d̪yːˈʁe">Endurer</phoneme>

Note : Pour de plus amples informations sur la phonétique française
http://fr.advantacell.com/wiki/International_Phonetic_Alphabet

D’ajouter une source audio avec la balise <audio>
<audio src="Monfichier.wav" />

De changer l’emphase et la rapidité de la synthèse vocale, à l’aide respectivement des balises <emphasis> et <prosody>
<emphasis level="strong">

<prosody rate="x-fast">

<say-as interpret-as="ordinal">10 étape du tour de France</say-as>

</prosody>

</emphasis>

De modifier la voix encours de route à l’aide de la balise <voice>
<voice xml:lang="fr-ca">

   C’est un texte en Français mais avec une voix Canadienne

 </voice>

<voice xml:lang=”en-US”>

   this is an English text
</voice>

Pour jouer et apprendre les balises rien de mieux que le faire par code, c'est ce que nous allons faire maintenant.

1)     Ajoutez un bouton comme illustré sur la figure suivante :

2)     Sur l’évènement click du bouton ajoutez le code suivant :
private void cmdSynthetiserSSML_Click(object sender, RoutedEventArgs e)
{
         SpeechSynthesizer s = new SpeechSynthesizer();              
         s.SpeakCompleted += new EventHandler<SpeakCompletedEventArgs>(s_SpeakCompleted);              
#if MICROSOFT_SPEECH
               ConfigureSoundPlayer(s);
#endif
  s.SpeakSsmlAsync(txtASynthetiser.Text);
         
}
Vous noterez que nous appelons ici la méthode SpeakSsmlAsync, qui prend comme paramètre une chaîne de caractère qui DOIT être au format SSML.

3)     Lancez l’application et testez avec le texte suivant :
<speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis' xml:lang='fr-FR'>
<voice xml:lang= "fr-fr">
   C’est un texte en Français mais avec une voix Française
 </voice>
<voice xml:lang= "fr-ca">
   C’est un texte en Français mais avec une voix Canadienne
 </voice>
<voice xml:lang= "en-us">
this is an English Text
</voice>

Maintenant que vous avez les bases, vous pouvez consolider votre expérience sur SSML en testant différentes balises.

4)     Pour charger un fichier au format SSML, il est possible d’utiliser l’objet FilePrompt
FilePrompt prompt = new FilePrompt("FichierSSML.xml", SynthesisMediaType.Ssml);

5)     Puis de le jouer directement à l’aide de la méthode SpeakAsync
s.SpeakAsync(prompt);

Conclusion

Comme nous venons de le voir, l'utilisation des API Speech pour de la synthèse vocale reste somme toute assez simple. Néanmoins, c'est assez simple, lorsque l'application ne lira que des messages simples, dans le cas contraire, il faudra sans doute investir plus en profondeur dans le standard SSML.

Dans la seconde partie de notre tutoriel, consacrée à la reconnaissance vocale, nous aborderons la manière de piloter une application, afin qu'elle puisse exécuter des actions simples à partir d'un ordre vocale. La reconnaissance vocale se basant sur une grammaire du standard du W3C SRGS (Speech Recoginition Grammar Specification), si vous souhaitez prendre de l'avance sur le sujet je ne peut que vous encourager à aller le découvrir à l'adresse suivante : http://www.w3.org/TR/speech-grammar

Eric Vernié

Article Powered by Windows Seven