Support multiple TTS voices on Windows.

chrome/browser/speech/tts_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <math.h>
 #include <sapi.h>
+#include <sphelper.h>
 
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
+#include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_comptr.h"
 #include "chrome/browser/speech/tts_controller.h"
 #include "chrome/browser/speech/tts_platform.h"
 
+namespace {
+
+// ISpObjectToken key and value names.
+const wchar_t kAttributesKey[] = L"Attributes";
+const wchar_t kGenderValue[] = L"Gender";
+const wchar_t kLanguageValue[] = L"Language";
+
+}  // anonymous namespace.
+
 class TtsPlatformImplWin : public TtsPlatformImpl {
  public:
   virtual bool PlatformImplAvailable() {
     return true;
   }
 
   virtual bool Speak(
       int utterance_id,
       const std::string& utterance,
       const std::string& lang,
@@ skipping 14 matching lines @@
   static TtsPlatformImplWin* GetInstance();
 
   static void __stdcall SpeechEventCallback(WPARAM w_param, LPARAM l_param);
 
  private:
   TtsPlatformImplWin();
   virtual ~TtsPlatformImplWin() {}
 
   void OnSpeechEvent();
 
+  void SetVoiceFromName(const std::string& name);
+
   base::win::ScopedComPtr<ISpVoice> speech_synthesizer_;
 
   // These apply to the current utterance only.
   std::wstring utterance_;
   int utterance_id_;
   int prefix_len_;
   ULONG stream_number_;
   int char_position_;
   bool paused_;
 
@@ skipping 12 matching lines @@
     const std::string& src_utterance,
     const std::string& lang,
     const VoiceData& voice,
     const UtteranceContinuousParameters& params) {
   std::wstring prefix;
   std::wstring suffix;
 
   if (!speech_synthesizer_.get())
     return false;
 
-  // TODO(dmazzoni): support languages other than the default: crbug.com/88059
+  SetVoiceFromName(voice.name);
 
   if (params.rate >= 0.0) {
     // Map our multiplicative range of 0.1x to 10.0x onto Microsoft's
     // linear range of -10 to 10:
     //   0.1 -> -10
     //   1.0 -> 0
     //  10.0 -> 10
     speech_synthesizer_->SetRate(static_cast<int32>(10 * log10(params.rate)));
   }
 
@@ skipping 72 matching lines @@
           status.dwRunningState == SPRS_IS_SPEAKING) {
         return true;
       }
     }
   }
   return false;
 }
 
 void TtsPlatformImplWin::GetVoices(
     std::vector<VoiceData>* out_voices) {
-  // TODO: get all voices, not just default voice.
-  // http://crbug.com/88059
-  out_voices->push_back(VoiceData());
-  VoiceData& voice = out_voices->back();
-  voice.native = true;
-  voice.name = "native";
-  voice.events.insert(TTS_EVENT_START);
-  voice.events.insert(TTS_EVENT_END);
-  voice.events.insert(TTS_EVENT_MARKER);
-  voice.events.insert(TTS_EVENT_WORD);
-  voice.events.insert(TTS_EVENT_SENTENCE);
-  voice.events.insert(TTS_EVENT_PAUSE);
-  voice.events.insert(TTS_EVENT_RESUME);
+  base::win::ScopedComPtr<IEnumSpObjectTokens> voice_tokens;
+  unsigned long voice_count;
+  if (S_OK != SpEnumTokens(SPCAT_VOICES, NULL, NULL, voice_tokens.Receive()))
+    return;
+  if (S_OK != voice_tokens->GetCount(&voice_count))
+    return;

[David Tseng, 2013/12/07 00:49:39]

Do we want to let the js client know there was an error retrieving voices?

[dmazzoni, 2013/12/09 17:12:24]

We don't have a mechanism for this currently, i.e. getVoices just returns a list
of voices from all sources (native and extensions), it doesn't have a way to say
that one of the two failed for some reason.

In practice I've never seen this fail, even when speech is in use by another
app. I think it'd be worth considering passing information through if we
encounter a specific error in the wild that app developers might want to handle
- but absent any specific example I think it's fine to just not return any
native voices, and let the app use Google Network Speech.

+
+  for (unsigned i = 0; i < voice_count; i++) {
+    VoiceData voice;
+
+    base::win::ScopedComPtr<ISpObjectToken> voice_token;
+    if (S_OK != voice_tokens->Next(1, voice_token.Receive(), NULL))
+      return;
+
+    base::win::ScopedCoMem<WCHAR> description;
+    if (S_OK != SpGetDescription(voice_token, &description))
+      continue;
+    voice.name = WideToUTF8(description.get());
+
+    base::win::ScopedComPtr<ISpDataKey> attributes;
+    if (S_OK != voice_token->OpenKey(kAttributesKey, attributes.Receive()))
+      continue;
+
+    base::win::ScopedCoMem<WCHAR> gender;
+    if (S_OK == attributes->GetStringValue(kGenderValue, &gender)) {
+      if (0 == _wcsicmp(gender.get(), L"male"))
+        voice.gender = TTS_GENDER_MALE;
+      else if (0 == _wcsicmp(gender.get(), L"female"))
+        voice.gender = TTS_GENDER_FEMALE;
+    }
+
+    base::win::ScopedCoMem<WCHAR> language;
+    if (S_OK == attributes->GetStringValue(kLanguageValue, &language)) {
+      int lcid_value;
+      base::HexStringToInt(WideToUTF8(language.get()), &lcid_value);
+      LCID lcid = MAKELCID(lcid_value, SORT_DEFAULT);
+      WCHAR locale_name[LOCALE_NAME_MAX_LENGTH] = {0};
+      LCIDToLocaleName(lcid, locale_name, LOCALE_NAME_MAX_LENGTH, 0);
+      voice.lang = WideToUTF8(locale_name);
+    }
+
+    voice.native = true;
+    voice.events.insert(TTS_EVENT_START);
+    voice.events.insert(TTS_EVENT_END);
+    voice.events.insert(TTS_EVENT_MARKER);
+    voice.events.insert(TTS_EVENT_WORD);
+    voice.events.insert(TTS_EVENT_SENTENCE);
+    voice.events.insert(TTS_EVENT_PAUSE);
+    voice.events.insert(TTS_EVENT_RESUME);
+    out_voices->push_back(voice);
+  }

[David Tseng, 2013/12/07 00:49:39]

Does this fetch voices across multiple tts engines? From my cursory reading of
this code, it doesn't seem to?

[dmazzoni, 2013/12/09 17:12:24]

SPCAT_VOICES returns voices from all engines in one big list. It's basically
just iterating over certain types of tokens in the registry.

 }
 
 void TtsPlatformImplWin::OnSpeechEvent() {
   TtsController* controller = TtsController::GetInstance();
   SPEVENT event;
   while (S_OK == speech_synthesizer_->GetEvents(1, &event, NULL)) {
     if (event.ulStreamNum != stream_number_)
       continue;
 
     switch (event.eEventId) {
@@ skipping 19 matching lines @@
     case SPEI_SENTENCE_BOUNDARY:
       char_position_ = static_cast<ULONG>(event.lParam) - prefix_len_;
       controller->OnTtsEvent(
           utterance_id_, TTS_EVENT_SENTENCE, char_position_,
           std::string());
       break;
     }
   }
 }
 
+void TtsPlatformImplWin::SetVoiceFromName(const std::string& name) {
+  if (name.empty())
+    return;
+
+  base::win::ScopedComPtr<IEnumSpObjectTokens> voice_tokens;
+  unsigned long voice_count;
+  if (S_OK != SpEnumTokens(SPCAT_VOICES, NULL, NULL, voice_tokens.Receive()))
+    return;
+  if (S_OK != voice_tokens->GetCount(&voice_count))
+    return;
+
+  for (unsigned i = 0; i < voice_count; i++) {
+    base::win::ScopedComPtr<ISpObjectToken> voice_token;
+    if (S_OK != voice_tokens->Next(1, voice_token.Receive(), NULL))
+      return;
+
+    base::win::ScopedCoMem<WCHAR> description;
+    if (S_OK != SpGetDescription(voice_token, &description))
+      continue;
+    if (name == WideToUTF8(description.get())) {
+      speech_synthesizer_->SetVoice(voice_token);

[David Tseng, 2013/12/07 00:49:39]

Did you notice any performance drawbacks with doing a voice lookup every time we
speak? Perhaps return earlier if the current voice is the requested voice?

[dmazzoni, 2013/12/09 17:12:24]

I didn't notice anything, but that's a good idea. Done.

+      break;
+    }
+  }
+}
+
 TtsPlatformImplWin::TtsPlatformImplWin()
   : utterance_id_(0),
     prefix_len_(0),
     stream_number_(0),
     char_position_(0),
     paused_(false) {
   speech_synthesizer_.CreateInstance(CLSID_SpVoice);
   if (speech_synthesizer_.get()) {
     ULONGLONG event_mask =
         SPFEI(SPEI_START_INPUT_STREAM) |
@@ skipping 11 matching lines @@
 TtsPlatformImplWin* TtsPlatformImplWin::GetInstance() {
   return Singleton<TtsPlatformImplWin,
                    LeakySingletonTraits<TtsPlatformImplWin> >::get();
 }
 
 // static
 void TtsPlatformImplWin::SpeechEventCallback(
     WPARAM w_param, LPARAM l_param) {
   GetInstance()->OnSpeechEvent();
 }