SpeechAPI OxfordProject

Exploring Microsoft Speech APIs

This article introduces the speech APIs, one of the services updated in Windows 10 and powered by the project Oxford. This article is divided into several parts:

I.Speech APIs features 

These APIs provide two major features :

  • Speech Recognition : Speech To Text (STT)

It converts spoken audio to text. The APIs can recognize audio coming from the microphone in real-time, or from an audio file.

  • Speech Synthesizer : Text To Speech (TTS)

It converts text to spoken audio when applications need to talk back to their users.

Microsoft Speech Platform


The Speech APIs are included in Windows 10 libraries, and also provided by the project oxford services, which require an Azure subscription.

II. Project Oxford Speech APIs 

These APIs are in a beta version, they work by sending data to Microsoft servers in the cloud, to use them we must have an Azure account. They also offer the Intent Recognition feature which can convert spoken audio to intent.

To use these APIs, follow the steps below:

  1. Using an Azure account, go to the Market Place to purchase the speechAPIs Service (which is for free 😉 ), then retrieve the primary or secondary key. Just in case you are using the Azure DreamSpark subscription, don’t be surprised if you don’t find this service. Unfortunately this type of account does not give access to Oxford Services.
  2. Download the Speech SDK of project oxford from here! if you are targeting another platform rather than Windows, have a look here you will find what you are looking for.


  • Speech To Text (STT):

The oxford version of Speech APIs offers two choice to make the STT:

  2. Client library

When using the REST API, we only get one recognition result back at the end of the session, but in the case of a client library, we also get partial result before getting the final recognition.

Setting up speech recognition begins with the Speech Recognition Service Factory. By using this factory, we can create an object which can make a recognition request to the Speech Recognition Service. This factory can create two types of objects:

  1. A Data Recognition Client : used for speech recognition with data (for example from an audio file). The data is broken up into buffers and each buffer is sent to the Speech Recognition Service.
  2. A Microphone Recognition Client : used for speech recognition from the microphone. The microphone is turned on, and data is sent to the Speech Recognition Service.

When creating a client from the factory, it can be configured in one of two modes:

  1. In ShortPhrase mode, an utterance may only be up to 15 seconds long, As data is sent to the server, the client will receive multiple partial results and one final multiple N-best choice result.
  2. In LongDictation mode, an utterance may only be up to 2 minutes long. As data is sent to the server, the client will receive multiple partial results and multiple final results.

Also the client can be configured for one of the following several languages:

  • American English: « en-us »
  • British English: « en-gb »
  • German: « de-de »
  • Spanish: « es-es »
  • French: « fr-fr »
  • Italian: « it-it »
  • Mandarin: « zh-cn »

Now, time to code 😀 you can implement the code below in a WPF app

string stt_primaryOrSecondaryKey = ConfigurationManager.AppSettings["primaryKey"];

// We have 2 choices : LongDictation or ShortPhrase
SpeechRecognitionMode stt_recoMode = SpeechRecognitionMode.LongDictation;

// For a Speech recognition from a Microphone
MicrophoneRecognitionClient stt_micClient = SpeechRecognitionServiceFactory.CreateMicrophoneClient(stt_recoMode, "fr-fr",

// For a Speech recognition from a data like wav file
DataRecognitionClient stt_dataClient = SpeechRecognitionServiceFactory.CreateDataClient(stt_recoMode, "fr-fr",

Then we must subscribe some events to get the result of the recognition. The Microphone Recognition Client & Data Recognition Client have the same Events as follow:

  • OnConversationError : Event fired when a conversation error occurs
  • OnIntent : Event fired when a Speech Recognition has finished, the recognized text has
    been parsed with LUIS for intent and entities, and the structured JSON result is available.
  • OnMicrophoneStatus : Event fired when the microphone recording status has changed.
  • OnPartialResponseReceived : Event fired when a partial response is received
  • OnResponseReceived : Event fired when a response is received

Inside the events, we can do whatever we want, displaying the result in a textBox for ex. and more…

// Event handlers for speech recognition results
sst_micClient.OnResponseReceived += OnResponseReceivedHandler;
sst_micClient.OnPartialResponseReceived += OnPartialResponseReceivedHandler;
sst_micClient.OnConversationError += OnConversationErrorHandler;
sst_micClient.OnMicrophoneStatus += OnMicrophoneStatus;

// Data Client event from an audio file for ex.
sst_dataClient.OnResponseReceived += OnResponseReceivedHandler;
sst_dataClient.OnPartialResponseReceived += OnPartialResponseReceivedHandler;
sst_dataClient.OnConversationError += OnConversationErrorHandler;

Now how do we start or stop the speech recognition? It’s simple, we just need to make a method call

// Turn on the microphone and stream audio to the Speech Recognition Service

// Turn off the microphone and the Speech Recognition

To convert an audio file to text, it’s easy, we just need to convert the file into a byte array and send it to the server for the recognition, like shown below:

if (!string.IsNullOrWhiteSpace(filename))
using (FileStream fileStream = new FileStream(filename, FileMode.Open, FileAccess.Read))
int bytesRead = 0;
byte[] buffer = new byte[1024];

bytesRead = fileStream.Read(buffer, 0, buffer.Length);
// Send of audio data to cloud service.
sst_dataClient.SendAudio(buffer, bytesRead);
} while (bytesRead > 0);

  • Text To Speech (TTS)

The TTS feature of project oxford can be used only through the REST API, and we have a complete example here.

The end-point to access the service is: https://speech.platform.bing.com/synthesize

The API uses HTTP POST to send audio back to the client. The maximum amount of audio returned for a given request will not exceed 15 seconds.

For any question about using this API, please refer to TTS through REST API documentation

III. Windows 10 Speech APIs

Windows 10 Speech APIs support all Windows 10 based devices including IoT hardware, phones, tablets, and PCs.

The Speech APIs in Windows 10 are represented under this two namespaces :


  1. Windows 10
  2. Visual Studio 2015
  3. Make sure that Windows Universal App Development Tools are installed in VS2015.

First of all we have to create a Windows 10 Universal application project in visual studio : New Project dialog box, click Visual C# > Windows > Windows Universal > Blank App (Windows Universal).

With Windows 10, applications don’t have the permission to use the microphone by default, so you must at first change the parameters of the universal application as follows:

Double click on the file Package.appxmanifest > Capablilites > Microphone > select the check box.

Note: The Windows 10 Speech APIs are using the languages installed in the Operating System.

  • Speech To Text (STT)

The STT feature using Windows 10 APIs works in online mode, if we want to make it available in offline mode we have to provide the necessary grammar manually.

To make this feature works we have 3 steps:

  • Create a SpeechRecognizer object,
  • Create an other object from SpeechRecognitionConstraint type and add it to the SpeechRecognizer object already created,
  • Compile the constraints.

SpeechRecognizer supports 2 types of recognition sessions:

  1. Continuous recognition sessions for prolonged audio input. A continuous session needs to be either explicitly ended or automatically times out after a configurable period of silence (default is 20 seconds).
  2. Speech recognition session for recognizing a short phrase. The session is terminated and the recognition results returned when a pause is detected by the recognizer.

Like shown in the code below

SpeechRecognizer speechRecognizer = new SpeechRecognizer();
// Here we choose a simple constraints scenario of dictation
var dictationConstraint = new SpeechRecognitionTopicConstraint(SpeechRecognitionScenario.Dictation, "dictation");
SpeechRecognitionCompilationResult result = await speechRecognizer.CompileConstraintsAsync();

A continuous recognition session can be started by calling SpeechRecognizer.ContinuousRecognitionSession.StartAsync() method and can be stoped by calling speechRecognizer.ContinuousRecognitionSession.StopAsync(). The SpeechRecognizer.ContinuousRecognitionSession object provides two events :

  • Completed : Occurs when a continuous recognition session ends.
  • ResultGenerated : Occurs when the speech recognizer returns the result from a continuous recognition session.

We have another event tied to the speechRecognizer object, which is the HypothesisGenerated event, occurs when a recognition result fragment is returned by the speech recognizer.

The code below show how to start the recognition:

public async void StartRecognition()
// The recognizer can only start listening in a continuous fashion if the recognizer is urrently idle.
// This prevents an exception from occurring.
if (speechRecognizer.State == SpeechRecognizerState.Idle)
await speechRecognizer.ContinuousRecognitionSession.StartAsync();
catch (Exception ex)
var messageDialog = new Windows.UI.Popups.MessageDialog(ex.Message, "Exception");
await messageDialog.ShowAsync();

To stop the recognition :

public async void StopRecognition()
if (speechRecognizer.State != SpeechRecognizerState.Idle)
await speechRecognizer.ContinuousRecognitionSession.StopAsync();

TXB_SpeechToText.Text = dictatedTextBuilder.ToString();
catch (Exception exception)
var messageDialog = new Windows.UI.Popups.MessageDialog(exception.Message, "Exception");
await messageDialog.ShowAsync();


  • Text To Speech (TTS)

This feature is available in offline and online mode, to make it works we have to create a SpeechSynthesizer object, then we set the speech synthesizer engine (voice) and generate a stream from the speechSynthesizer.SynthesizeTextToStreamAsync method by passing the text we want to read in parameter.

To read the stream we have to use a MediaElement object, like shown in the code below:

SpeechSynthesizer speechSynthesizer = new SpeechSynthesizer();
speechSynthesizer.Voice = SpeechSynthesizer.DefaultVoice;
//Init the media element which will wrap tthe text to speech
MediaElement mediaElement = new MediaElement();
//We have to add the mediaElement to the Grid otherwise it won't work

var stream = await speechSynthesizer.SynthesizeTextToStreamAsync("Hello World!");
mediaElement.SetSource(stream, stream.ContentType);

Managing voice commands using the STT and TTS features

We can make the applications implementing these APIs more interactive, by passing some commands using voice. Once the command is executed, the app will confirm this, using the TTS feature. To do that, we can use the STT events, like shown in the code below:

private async  void ContinuousRecognitionSession_ResultGenerated(SpeechContinuousRecognitionSession sender, SpeechContinuousRecognitionResultGeneratedEventArgs args)
// We can ignore the generated text using the level of the conversion confidence (Low,Medium,High)
if (args.Result.Confidence == SpeechRecognitionConfidence.Medium || args.Result.Confidence == SpeechRecognitionConfidence.High)
// The key word to activate any command
//ex. user says : text red, the key word is text and the command is red
string command = "text";

if (args.Result.Text.ToLower().Contains(command))
string result = args.Result.Text.ToLower();
string value = result.Substring(result.IndexOf(command) + command.Length + 1).ToLower();
//The generated text may ends with a point
value = value.Replace(".", "");
switch (value)
case "in line": case "line": case "in-line":
dictatedTextBuilder.AppendFormat("{0}", Environment.NewLine);
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
ReadSpecilaCommandToUser("Carriage return command is activated");
case "blue":
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
TXB_SpeechToText.Foreground = new SolidColorBrush(Colors.Blue);
ReadSpecilaCommandToUser("Blue color command is activated");
case "red":
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
TXB_SpeechToText.Foreground = new SolidColorBrush(Colors.Red);
ReadSpecilaCommandToUser("Red color command is activated");
case "green":
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
TXB_SpeechToText.Foreground = new SolidColorBrush(Colors.Green);
ReadSpecilaCommandToUser("Green color command is activated");
case "black":
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
TXB_SpeechToText.Foreground = new SolidColorBrush(Colors.Black);
ReadSpecilaCommandToUser("Black color command is activated");
dictatedTextBuilder.Append(args.Result.Text + " ");

await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
TXB_SpeechToText.Text = dictatedTextBuilder.ToString();



private async void ReadSpecilaCommandToUser(string text)
if (!string.IsNullOrWhiteSpace(text))
using (SpeechSynthesizer speech = new SpeechSynthesizer())
speech.Voice = SpeechSynthesizer.AllVoices.FirstOrDefault(item => item.Language.Equals(language.LanguageTag));
SpeechSynthesisStream stream = await speech.SynthesizeTextToStreamAsync(text);

mediaElement.SetSource(stream, stream.ContentType);


IV. Demo

The video below shows how to edit text by voice, the app is using the Windows 10 Speech APIs:

Going further


Speech APIs – Universal Windows Platform:

SpeechAPIs – Project Oxford: https://github.com/Microsoft/ProjectOxford-ClientSDK/tree/master/Speech

Project Oxford : https://www.projectoxford.ai

Sécurité dynamique dans les cubes SSAS avec SQL Server 2012

Avec l’ouverture des données Power BI Self-Service vers les utilisateurs (vu dans plusieurs de mes missions) les métiers veulent gérer eux même les droits ou périmètres sur de nombreux utilisateurs finaux (>1000).

En effet dans certains domaines, nous avons une forte contrainte de confidentialité des données contenues dans les cubes SSAS. Les juridictions qui doivent s’appliquer peuvent être changées avec des cadences variables allant de la journée, à des cadences inférieures (temps réel). Pour cela, l’ensemble de la sécurité mise en œuvre est stocké dans la source de données du cube, qui détermine qui peut voir quoi.

A travers cet article, nous allons voir comment rendre dynamique une sécurité de cube SSAS basée sur l’appel à une procédure stockée.

Lire la suite

Microsoft Ignite 2015 – Du lundi 4 mai au Mercredi 6 mai par Stéphane

Par Stéphane,
Pôle SharePoint MCNEXT

LUNDI 4 MAI 2015
1 – DevOps as a strategy for business agility
2 – Deep Div into Safe Sharepoint Branding in Office 365 Using Repeatable Patterns and Practices
3 – Building solutions with Office 365

MARDI 5 MAI 2015
4 – Get Your Hands Dirty with the Office 365 APIs, Authentication, and SDKs
5 – Designing and Applying Information Architecture for Microsoft SharePoint and Office 365
6 – Building business apps like they do in the valley with Angular, Node.js, and more..

7 – Understanding the IT Pro’s dynamic operations role within DevOps
8 – What’s new for build automation in Team Foundation Server and Visual Studio Online
9 – Bose Turns Up the Volume with Microsoft Office 365
10 – Visual Studio 2015 for Web Developers
11 – Implementing Next Generation SharePoint Hybrid Search with the Cloud Search Service Application

Lire la suite

[Build 14] – Windows Phone 8.1 Security Features

Mail de John
Samedi 5 avril 2014 20:33


Windows Phone 8.1 Security Features 


Les objectifs :
– Minimiser le temps nécessaire aux utilisateurs de ré-entrer leurs identifiants
– Offrir aux développeurs un modèle de programmation riche
– Transformer le téléphone en un appareil d’authentification

Microsoft Account :
– Suppression du vieux protocole d’authentification du Windows Phone hérité de Windows Mobile et remplacement par celui de WinRT
– C’est le principal fournisseur d’identité sur Windows Phone
– La majorité des utilisateurs sont authentifiés avec leur compte MSA
– Ajout du Single Sign ON
– Windows.Security.Authentication.OnlineId est le namespace pour ces nouvelles API
– Convergés avec Windows

Avantages de MSA :
– Roaming des données entre les appareils
– Les utilisateurs n’auront probablement pas besoin de ré-entrer leurs identifiants
– MSA évolue indépendamment de l’OS
– Meilleure robustesse et sécurité

Trois options pour utiliser MSA :
– OnlineId – Meilleure méthode
– Web Authentication Broker (OAuth)
– Live SDK – Permet d’accéder à OneDrive

Démonstration d’une authentification utilisant OnlineId

Web Authentication Broker

Description du fonctionnement du processus d’authentification OAuth avec schemas à l’appui.
Auparavant avec une webview :
– Pas de single sign-on
– Pas d’isolation des identifiants
– Ne fonctionne pas dans les cas de faible mémoire

Maintenant avec le WAB :
– Utilisation de OAuth
– Avantages
o Single Sign On
o API simple
o Isolation des identifiants
– Windows.Security.Authentication.Web
– API similaire à Windows mais optimisée pour les situations à faible mémoire

Démonstration du Web Broker et du « Continuation Pattern »

Stockage des identifiants :
– Utilisation du Credential Locker
– Windows.Security.Credentials
o PasswordVault
o WebAccount non supporté sur Phone
– Roaming des identifiants avec le Credential Locker

Crypto et certificats :
– Convergence avec WinRT
– Nouveaux namespaces

Virtual Smart Card :
– Autorise l’authentification “two factor” pour le S/MIME et les scenarii de navigation sécurisée
– Les clefs d’authentification sont liées au matériel et ne peuvent être accéder tant que l’utilisateur n’a pas fourni son code PIN
– VSC est construit au-dessus de TPM (Trusted Platform Module)

Présentation de l’architecture de VSC
Démonstration de VSC

Applications sur carte SD :
– Pas d’API mais les développeurs peuvent désactiver le stockage de leurs applications sur carte SD depuis le manifest
– Cryptage des fichiers de l’application sur la carte SD (différentes clefs entre le programme et les données de l’application)
– Contrôle d’accès pour FAT

[Build 14] – Modern Camera and Imaging Apps in Windows and Windows Phone

Mail de Mehdi
Vendredi 4 avril 2014 10:31

Modern Camera and Imaging Apps in Windows and Windows Phone
// Speakers :
Jeff Day, Rene Schulte
// On nous présente les nouveautés de la fonction caméra.
Première constatation (comme dans les autres sessions) l’API de caméra se cale maintenant sur celle de windows.


On peut toujours utiliser l’ancienne api, mais elle n’est disponible que pour les applis Silverlight.
Nouveautés :
– On peut enregistrer une (des) photo(s) durant une vidéo.
– Full acess video library i/o access
CameraCaptureUI n’est pas disponible sur téléphone on passe plutôt avec le fileopenpicker qui nous permet soit de récupérer une photo de la pellicule ou capturer une nouvelle photo.

Le workflow est donc différent pour les appli Windows phone, pas de async await, mais plutôt on « quitte » l’appli pour ouvrir le fileopenpiker ensuite quand on revient vers l’appli l’event activated est déclenché, il faut donc faire les branchements qu’il faut pour gérer cela.

Pour de la capture en temps réel le partage de code est possible puisqu’on utilise une UI spécifique qu’il faut développer.
La nouvelle api nous donne accès à de nouvelles fonctionnalités comme la brillance le zoom le focus le contraste …
Avec ScreenCapture, on peut maintenant capturer en vidéo ce qui se passe dans l’application (valable uniquement sur phone).
Deux démos :

– La première « basic capturing » exemple de capture vidéo sur windows et WP.

– La deuxième un peu plus avancé ou le speaker nous montre comment coder une capture avec le mode HDR qui n’est disponible que sur WP (et que sur certains téléphones avec une puce spécifique, les téléphones actuels ne seront pas forcement supportés cela dépendra du driver, et donc du constructeur) pour l’instant aucun téléphone ne le supporte, il n’y a que le simulateur qui le fait 🙂 . C’est au développer de vérifier la disponibilité de cette fonction dans le code, aucun flag n’est présent dans le manifest pour alerter l’utilisateur de cette capacité spécifique.



[Build 14] – What’s new with Windows Phone Silverlight Apps !

Mail de John
Vendredi 4 avril 2014 06:11

What’s new with Windows Phone Silverlight Apps!


Différences entre les applications XAML et les applications Silverlight.
Le framework XAML est le framework du futur. C’est là où les prochaines mises à jour auront lieu. Mais le framework Silverlight continuera à être mis à jour quelques temps afin de suivre les évolutions du framework XAML pour les applications existantes.

La convergence entre les API est de l’odre de 90%.

Cependant certaines API n’ont pas encore migrées :

– Lenses
– Camera Capture Task
– Clipboard
– Lockscreen Wallpaper
– Ringtone et Alarmes
– Simple sound effects (XNA)
– Photos Extensibility
– Search Extras


On enchaîne par une démonstration de la migration d’une application Silverlight 8.0 vers Silverlight 8.1

Les applications Silverlight 8.1 s’exécutent dans le même contexte que les applications WinRT. Pour cette raison, les applications Silverlight 8.1 disposent maintenant d’un fichier appxmanifest en plus de l’historique fichier WMAppManifest.xml. Les deux doivent être mis maintenus à jour.

Lorsque l’on migre en 8.1 il y a quelques « breaking changes » :

– CLR/Silverlight bug fixes
o Array.Sort (IntrospectiveSort à la place du QuickSort)
o DateTime.Parse (correction de bugs)

– Différences au niveau de contexte d’exécution des applications WinRT
o Fast App Resume est activé par défaut (resume vs replace)
o Appuyer sur back ferme l’application, à la différence des Universal Apps, mais il existe une API spéciale qu’il est recommandé d’utiliser pour que les applications Silverlight 8.1 fonctionnent comme les Universal Apps.

Fonctionnalités non supportés dans Silverlight 8.1 :
– Background Audio (existe dans les Universal Apps)
– Continuous Background Execution Agents (GPS Apps)

Nouvelles fonctionnalités et mises à jour :

– Nouvelles API disponibles pour les applications Natives (C++)
– WinRT APIs
– SD Card Support
– Share Source
– Share Target
– WNS Push Notification Trigger
– WNS Notifications
– Storage
– GeoFencing
– Bluetooth 4.0
– Background Tasks
– Known Folders (Audio/Video/Photos/…)
– Appointments / Calendar Enhancements
– Email with Attachments
– Web Authentication
– Data Roaming
– Accessibility (UIA, Large Text, High Contrast)

On a ensuite une démonstration du remplacement d’un EmailComposeTask par un Share Contract avec une pièce jointe suivi d’une autre démonstration où on ajoute une BackgroundTask.

Le Store supporte maintenant 3 versions d’une application (7.1, 8.0 et 8.1).
Avant de pouvoir déployer une application 8.1 pour la première fois, il faut réserver un nom spécifique à cette version. Ce nom doit se trouver dans le appxmanifest et il faut l’éditer à la main en mode texte (voir slides de la présentation).