Support multiple voices for all available modules (text-to-speech engines) on Linux.

chrome/browser/speech/tts_linux.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 <map>
+
+#include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/speech/tts_platform.h"
 #include "content/public/browser/browser_thread.h"
 
 #include "library_loaders/libspeechd.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const char kNotSupportedError[] =
     "Native speech synthesis not supported on this platform.";
 
+struct SPDChromeVoice {
+std::string name;

[dmazzoni, 2013/05/28 07:30:02]

nit: indent struct members

+std::string module;
+};
+
 }  // namespace
 
 class TtsPlatformImplLinux : public TtsPlatformImpl {
  public:
   virtual bool PlatformImplAvailable() OVERRIDE;
   virtual bool Speak(
       int utterance_id,
       const std::string& utterance,
       const std::string& lang,
       const VoiceData& voice,
@@ skipping 29 matching lines @@
   static SPDNotificationType current_notification_;
 
   base::Lock initialization_lock_;
   LibSpeechdLoader libspeechd_loader_;
   SPDConnection* conn_;
 
   // These apply to the current utterance only.
   std::string utterance_;
   int utterance_id_;
 
+  // Map a string composed of a voicename and module to the voicename. Used to
+  // uniquely identify a voice across all available modules.
+  scoped_ptr<std::map<std::string, SPDChromeVoice> > all_native_voices_;
+
   friend struct DefaultSingletonTraits<TtsPlatformImplLinux>;
 
   DISALLOW_COPY_AND_ASSIGN(TtsPlatformImplLinux);
 };
 
 // static
 SPDNotificationType TtsPlatformImplLinux::current_notification_ =
     SPD_EVENT_END;
 
 TtsPlatformImplLinux::TtsPlatformImplLinux()
@@ skipping 66 matching lines @@
     error_ = kNotSupportedError;
     return false;
   }
 
   // Speech dispatcher's speech params are around 3x at either limit.
   float rate = params.rate > 3 ? 3 : params.rate;
   rate = params.rate < 0.334 ? 0.334 : rate;
   float pitch = params.pitch > 3 ? 3 : params.pitch;
   pitch = params.pitch < 0.334 ? 0.334 : pitch;
 
+  std::map<std::string, SPDChromeVoice>::iterator it =
+                         all_native_voices_->find(voice.name);

[dmazzoni, 2013/05/28 07:30:02]

nit: indent just 4

+  if (it != all_native_voices_->end()) {
+    libspeechd_loader_.spd_set_output_module(conn_, it->second.module.c_str());
+    libspeechd_loader_.spd_set_synthesis_voice(conn_, it->second.name.c_str());
+  }
+
   // Map our multiplicative range to Speech Dispatcher's linear range.
   // .334 = -100.
   // 3 = 100.
   libspeechd_loader_.spd_set_voice_rate(conn_, 100 * log10(rate) / log10(3));
   libspeechd_loader_.spd_set_voice_pitch(conn_, 100 * log10(pitch) / log10(3));
 
   utterance_ = utterance;
   utterance_id_ = utterance_id;
 
   if (libspeechd_loader_.spd_say(conn_, SPD_TEXT, utterance.c_str()) == -1) {
@@ skipping 12 matching lines @@
   }
   return true;
 }
 
 bool TtsPlatformImplLinux::IsSpeaking() {
   return current_notification_ == SPD_EVENT_BEGIN;
 }
 
 void TtsPlatformImplLinux::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_CANCELLED);
-  voice.events.insert(TTS_EVENT_MARKER);
+  if (!all_native_voices_.get()) {
+    all_native_voices_.reset(new std::map<std::string, SPDChromeVoice>());
+    char** modules = libspeechd_loader_.spd_list_modules(conn_);

[dmazzoni, 2013/05/28 07:30:02]

Technically I think this array and each string within it needs to be freed with
free.
The libspeechd docs are really unclear, but I looked at the source
(see spd_execute_command_with_list_reply in particular) and these are
all malloced and returned.

+    if (!modules) {

[dmazzoni, 2013/05/28 07:30:02]

nit: normally blocks with a single-line body don't need braces in chromium C++
code

+      return;
+    }
+    for (int i = 0; modules[i]; i++) {
+      SPDVoice** native_voices =
+          libspeechd_loader_.spd_list_synthesis_voices(conn_);

[dmazzoni, 2013/05/28 07:30:02]

This doesn't seem to depend on the for loop index - does it belong outside the
loop?

+      if (!native_voices) {
+        continue;
+      }
+      char* module = modules[i];
+      for (int j = 0; native_voices[j]; j++) {
+        SPDVoice* native_voice = native_voices[j];
+        SPDChromeVoice native_data;
+        native_data.name = native_voice->name;
+        native_data.module = module;
+        std::string key;
+        key.append(native_data.name);
+        key.append(" ");
+        key.append(native_data.module);
+        all_native_voices_->insert(
+            std::pair<std::string, SPDChromeVoice>(key, native_data));
+      }
+    }
+  }
+
+  for (std::map<std::string, SPDChromeVoice>::iterator it =
+           all_native_voices_->begin();
+       it != all_native_voices_->end();
+       it++) {
+    out_voices->push_back(VoiceData());
+    VoiceData& voice = out_voices->back();
+    voice.native = true;
+    voice.name = it->first;
+    voice.events.insert(TTS_EVENT_START);
+    voice.events.insert(TTS_EVENT_END);
+    voice.events.insert(TTS_EVENT_CANCELLED);
+    voice.events.insert(TTS_EVENT_MARKER);
+  }
 }
 
 void TtsPlatformImplLinux::OnSpeechEvent(SPDNotificationType type) {
   TtsController* controller = TtsController::GetInstance();
   switch (type) {
   case SPD_EVENT_BEGIN:
   case SPD_EVENT_RESUME:
     controller->OnTtsEvent(utterance_id_, TTS_EVENT_START, 0, std::string());
     break;
   case SPD_EVENT_END:
@@ skipping 49 matching lines @@
 // static
 TtsPlatformImplLinux* TtsPlatformImplLinux::GetInstance() {
   return Singleton<TtsPlatformImplLinux,
                    LeakySingletonTraits<TtsPlatformImplLinux> >::get();
 }
 
 // static
 TtsPlatformImpl* TtsPlatformImpl::GetInstance() {
   return TtsPlatformImplLinux::GetInstance();
 }